code
stringlengths 1
13.8M
|
|---|
predictCox <- function(object,
times,
newdata=NULL,
centered = TRUE,
type=c("cumhazard","survival"),
keep.strata = TRUE,
keep.times = TRUE,
keep.newdata = FALSE,
keep.infoVar = FALSE,
se = FALSE,
band = FALSE,
iid = FALSE,
confint = (se+band)>0,
diag = FALSE,
average.iid = FALSE,
store.iid = "full"){
if (missing(times)) {
nTimes <- 0
times <- numeric(0)
}else{
nTimes <- length(times)
}
needOrder <- (nTimes[1]>0 && is.unsorted(times))
if (all(!is.na(times)) && needOrder) {
order.times <- order(times)
oorder.times <- order(order.times)
times.sorted <- sort(times)
}else{
if (nTimes==0){
times.sorted <- numeric(0)
} else{
times.sorted <- times
order.times <- 1:nTimes
oorder.times <- 1:nTimes
}
}
object.n <- coxN(object)
object.modelFrame <- coxModelFrame(object)
infoVar <- coxVariableName(object, model.frame = object.modelFrame)
object.baseEstimator <- coxBaseEstimator(object)
is.strata <- infoVar$is.strata
object.levelStrata <- levels(object.modelFrame$strata)
nStrata <- length(object.levelStrata)
nVar.lp <- length(infoVar$lpvars)
object.modelFrame[,c("strata.num") := as.numeric(.SD$strata) - 1]
object.modelFrame[,c("eXb") := exp(coxLP(object, data = NULL, center = if(is.null(newdata)){centered}else{FALSE}))]
rm.name <- setdiff(names(object.modelFrame),c("start","stop","status","eXb","strata","strata.num"))
if(length(rm.name)>0){
object.modelFrame[,c(rm.name) := NULL]
}
object.modelFrame[, c("statusM1") := 1-.SD$status]
object.modelFrame[, c("XXXindexXXX") := 1:.N]
data.table::setkeyv(object.modelFrame, c("strata.num","stop","start","statusM1"))
if(!is.null(attr(times,"etimes.max"))){
etimes.max <- attr(times,"etimes.max")
attr(times,"etimes.max") <- NULL
attr(times.sorted,"etimes.max") <- etimes.max
}else if(is.strata){
if(nVar.lp==0){
iDTtempo <- object.modelFrame[, .SD[which.max(.SD$stop)], by = "strata.num"]
etimes.max <- iDTtempo[,if(.SD$status==1){1e12}else{.SD$stop}, by = "strata.num"][[2]]
}else{
etimes.max <- object.modelFrame[, max(.SD$stop), by = "strata.num"][[2]]
}
}else{
if(nVar.lp==0 && (utils::tail(object.modelFrame$status,1)==1)){
etimes.max <- 1e12
}else{
etimes.max <- max(object.modelFrame[["stop"]])
}
}
if(nTimes[1]>0 && any(is.na(times))){
stop("Missing (NA) values in argument \'times\' are not allowed.\n")
}
type <- tolower(type)
if(any(type %in% c("hazard","cumhazard","survival") == FALSE)){
stop("type can only be \"hazard\", \"cumhazard\" or/and \"survival\" \n")
}
if(!is.null(object$weights) && !all(object$weights==1)){
stop("predictCox does not know how to handle Cox models fitted with weights \n")
}
if(!is.null(object$naive.var)){
stop("predictCox does not know how to handle fraitly \n")
}
if(any(object.modelFrame[["start"]]!=0)){
warning("The current version of predictCox was not designed to handle left censoring \n",
"The function may be used on own risks \n")
}
if(object.baseEstimator == "exact"){
stop("Prediction with exact handling of ties is not implemented.\n")
}
if(!is.null(object$call$tt)){
stop("predictCox does not know how to handle time varying effects.\n")
}
if(!is.null(coef(object)) && any(is.na(coef(object)))){
print(coef(object))
stop("Incorrect object",
"One or several model parameters have been estimated to be NA \n")
}
if (missing(newdata) && (se || iid || average.iid)){
stop("Argument 'newdata' is missing. Cannot compute standard errors in this case.")
}
if(!is.null(newdata)){
if(missing(times) || nTimes[1]==0){
stop("Time points at which to evaluate the predictions are missing \n")
}
if(!is.vector(times)){
stop("Argument \'times\' must be a vector \n")
}
name.regressor <- c(infoVar$lpvars.original, infoVar$stratavars.original)
if(length(name.regressor) > 0 && any(name.regressor %in% names(newdata) == FALSE)){
stop("Missing variables in argument \'newdata\': \"",
paste0(setdiff(name.regressor,names(newdata)), collapse = "\" \""),
"\"\n")
}
if(se[1] && ("hazard" %in% type)){
stop("Standard error cannot be computed for the hazard \n")
}
if(band[1] && ("hazard" %in% type)){
stop("confidence bands cannot be computed for the hazard \n")
}
}
if(!is.logical(diag)){
stop("Argument \'diag\' must be of type logical \n")
}
if(diag){
if(NROW(newdata)!=length(times)){
stop("When argument \'diag\' is TRUE, the number of rows in \'newdata\' must equal the length of \'times\' \n")
}
}
if(average.iid==TRUE && !is.null(attr(average.iid,"factor"))){
if(is.null(store.iid) && !is.null(object$iid$store.iid)){
store.iid <- object$iid$store.iid
}
if(store.iid == "full"){
if(iid){
stop("Attribute \"factor\" of argument \'average.iid\' not available when \'iid\' is TRUE with argument \'store.iid\' set to \"full\" \n",
"Consider setting \'store.iid\' set to \"minimal\" \n")
}
if(se){
stop("Attribute \"factor\" of argument \'average.iid\' not available when \'se\' is TRUE with argument \'store.iid\' set to \"full\" \n",
"Consider setting \'store.iid\' set to \"minimal\" \n")
}
}
test.list <- !is.list(attr(average.iid,"factor"))
if(test.list){
stop("Attribute \"factor\" of argument \'average.iid\' must be a list \n")
}
test.matrix <- any(unlist(lapply(attr(average.iid,"factor"), is.matrix))==FALSE)
if(test.matrix){
stop("Attribute \"factor\" of argument \'average.iid\' must be a list of matrices \n")
}
for(iFactor in 1:length(attr(average.iid,"factor"))){
if((diag == FALSE) && (NCOL(attr(average.iid,"factor")[[iFactor]])==1) && (nTimes > 1)){
attr(average.iid,"factor")[[iFactor]] <- matrix(attr(average.iid,"factor")[[iFactor]][,1],
nrow = NROW(attr(average.iid,"factor")[[iFactor]]),
ncol = nTimes, byrow = FALSE)
}
if(any(dim(attr(average.iid,"factor")[[iFactor]])!=c(NROW(newdata), diag + (1-diag)*nTimes))){
stop("Attribute \"factor\" of argument \'average.iid\' must be a list of matrices of size ",new.n,",",diag + (1-diag)*nTimes," \n")
}
}
}
Lambda0 <- baseHaz_cpp(starttimes = object.modelFrame$start,
stoptimes = object.modelFrame$stop,
status = object.modelFrame$status,
eXb = object.modelFrame$eXb,
strata = object.modelFrame$strata.num,
nPatients = object.n,
nStrata = nStrata,
emaxtimes = etimes.max,
predtimes = times.sorted,
cause = 1,
Efron = (object.baseEstimator == "efron"))
Lambda0$strata <- factor(Lambda0$strata, levels = 0:(nStrata-1), labels = object.levelStrata)
if (is.null(newdata)){
if (!("hazard" %in% type)){
Lambda0$hazard <- NULL
}
if ("survival" %in% type){
Lambda0$survival = exp(-Lambda0$cumhazard)
}
if (!("cumhazard" %in% type)){
Lambda0$cumhazard <- NULL
}
if (keep.times==FALSE){
Lambda0$times <- NULL
}
if (keep.strata[[1]]==FALSE ||(is.null(match.call()$keep.strata) && !is.strata)){
Lambda0$strata <- NULL
}
if( keep.newdata[1]==TRUE){
Lambda0$newdata <- object.modelFrame
}
add.list <- list(lastEventTime = etimes.max,
se = FALSE,
band = FALSE,
type = type,
nTimes = nTimes,
baseline = TRUE,
var.lp = infoVar$lpvars.original,
var.strata = infoVar$stratavars.original)
if(keep.infoVar){
add.list$infoVar <- infoVar
}
Lambda0[names(add.list)] <- add.list
class(Lambda0) <- "predictCox"
return(Lambda0)
} else {
out <- list()
new.n <- NROW(newdata)
setDT(newdata)
new.eXb <- exp(coxLP(object, data = newdata, center = FALSE))
new.strata <- coxStrata(object, data = newdata,
sterms = infoVar$strata.sterms,
strata.vars = infoVar$stratavars,
strata.levels = infoVar$strata.levels)
new.levelStrata <- levels(droplevels(new.strata))
if (is.strata==FALSE){
if(diag){
if(needOrder){
iTimes <- prodlim::sindex(jump.times = Lambda0$times, eval.times = times.sorted[oorder.times])
}else{
iTimes <- prodlim::sindex(jump.times = Lambda0$times, eval.times = times.sorted)
}
}
if ("hazard" %in% type){
if(diag){
out$hazard <- cbind(new.eXb * Lambda0$hazard[iTimes])
}else{
out$hazard <- (new.eXb %o% Lambda0$hazard)
if (needOrder) out$hazard <- out$hazard[,oorder.times,drop=0L]
}
}
if ("cumhazard" %in% type || "survival" %in% type){
if(diag){
cumhazard <- cbind(new.eXb * Lambda0$cumhazard[iTimes])
}else{
cumhazard <- new.eXb %o% Lambda0$cumhazard
if (needOrder){cumhazard <- cumhazard[,oorder.times,drop=0L]}
}
if ("cumhazard" %in% type){
out$cumhazard <- cumhazard
}
if ("survival" %in% type){
out$survival <- exp(-cumhazard)
}
}
}else{
if ("hazard" %in% type){
out$hazard <- matrix(0, nrow = new.n, ncol = nTimes*(1-diag)+diag)
}
if ("cumhazard" %in% type){
out$cumhazard <- matrix(NA, nrow = new.n, ncol = nTimes*(1-diag)+diag)
}
if ("survival" %in% type){
out$survival <- matrix(NA, nrow = new.n, ncol = nTimes*(1-diag)+diag)
}
for(S in new.levelStrata){
id.S <- which(Lambda0$strata==S)
newid.S <- which(new.strata==S)
if(diag){
if(needOrder){
iSTimes <- prodlim::sindex(jump.times = Lambda0$times[id.S], eval.times = times.sorted[oorder.times[newid.S]])
}else{
iSTimes <- prodlim::sindex(jump.times = Lambda0$times[id.S], eval.times = times.sorted[newid.S])
}
}
if ("hazard" %in% type){
if(diag){
out$hazard[newid.S] <- new.eXb[newid.S] * Lambda0$hazard[id.S][iSTimes]
}else{
out$hazard[newid.S,] <- new.eXb[newid.S] %o% Lambda0$hazard[id.S]
if (needOrder){
out$hazard[newid.S,] <- out$hazard[newid.S,oorder.times,drop=0L]
}
}
}
if ("cumhazard" %in% type || "survival" %in% type){
if(diag){
cumhazard.S <- cbind(new.eXb[newid.S] * Lambda0$cumhazard[id.S][iSTimes])
}else{
cumhazard.S <- new.eXb[newid.S] %o% Lambda0$cumhazard[id.S]
if (needOrder){
cumhazard.S <- cumhazard.S[,oorder.times,drop=0L]
}
}
if ("cumhazard" %in% type){
out$cumhazard[newid.S,] <- cumhazard.S
}
if ("survival" %in% type){
out$survival[newid.S,] <- exp(-cumhazard.S)
}
}
}
}
if(se[[1]] || band[[1]] || iid[[1]] || average.iid[[1]]){
if(nVar.lp > 0){
new.LPdata <- prodlim::model.design(infoVar$lp.sterms,
data = newdata,
specialsFactor = TRUE,
dropIntercept = TRUE)$design
if(NROW(new.LPdata)!=NROW(newdata)){
stop("NROW of the design matrix and newdata differ \n",
"maybe because newdata contains NA values \n")
}
}else{
new.LPdata <- matrix(0, ncol = 1, nrow = new.n)
}
data.table::setkeyv(object.modelFrame,"XXXindexXXX")
if(diag){
Lambda0$oorder.times <- oorder.times
}else{
Lambda0$oorder.times <- 1:nTimes
}
export <- c("iid"[(iid+band)>0],"se"[(se+band)>0],"average.iid"[average.iid==TRUE])
if(!is.null(attr(average.iid,"factor"))){
if(diag){
attr(export,"factor") <- attr(average.iid,"factor")
}else{
attr(export,"factor") <- lapply(attr(average.iid,"factor"), function(iF){
iF[,order.times,drop=FALSE]
})
}
}
if(diag){
times2 <- times
}else{
times2 <- times.sorted
}
attr(times2,"etimes.max") <- attr(times.sorted,"etimes.max")
outSE <- calcSeCox(object,
times = times2,
nTimes = nTimes,
type = type,
diag = diag,
Lambda0 = Lambda0,
object.n = object.n,
object.time = object.modelFrame$stop,
object.eXb = object.modelFrame$eXb,
object.strata = object.modelFrame$strata,
nStrata = nStrata,
new.n = new.n,
new.eXb = new.eXb,
new.LPdata = new.LPdata,
new.strata = new.strata,
new.survival = if(diag){out$survival}else{out$survival[,order.times,drop=FALSE]},
nVar.lp = nVar.lp,
export = export,
store.iid = store.iid)
if((iid+band)>0){
if ("hazard" %in% type){
if (needOrder[1] && (diag[1] == FALSE))
out$hazard.iid <- outSE$hazard.iid[,oorder.times,,drop=0L]
else
out$hazard.iid <- outSE$hazard.iid
}
if ("cumhazard" %in% type){
if (needOrder[1] && (diag[1] == FALSE))
out$cumhazard.iid <- outSE$cumhazard.iid[,oorder.times,,drop=0L]
else
out$cumhazard.iid <- outSE$cumhazard.iid
}
if ("survival" %in% type){
if (needOrder[1] && (diag[1] == FALSE))
out$survival.iid <- outSE$survival.iid[,oorder.times,,drop=0L]
else
out$survival.iid <- outSE$survival.iid
}
}
if(average.iid == TRUE){
if ("hazard" %in% type){
if (needOrder && (diag[1] == FALSE)){
if(is.list(outSE$hazard.average.iid)){
out$hazard.average.iid <- lapply(outSE$hazard.average.iid, function(iIID){iIID[,oorder.times,drop=0L]})
}else{
out$hazard.average.iid <- outSE$hazard.average.iid[,oorder.times,drop=0L]
}
}else{
out$hazard.average.iid <- outSE$hazard.average.iid
}
}
if ("cumhazard" %in% type){
if (needOrder && (diag[1] == FALSE)){
if(is.list(outSE$cumhazard.average.iid)){
out$cumhazard.average.iid <- lapply(outSE$cumhazard.average.iid, function(iIID){iIID[,oorder.times,drop=0L]})
}else{
out$cumhazard.average.iid <- outSE$cumhazard.average.iid[,oorder.times,drop=0L]
}
}else{
out$cumhazard.average.iid <- outSE$cumhazard.average.iid
}
}
if ("survival" %in% type){
if (needOrder && (diag[1] == FALSE)){
if(is.list(outSE$survival.average.iid)){
out$survival.average.iid <- lapply(outSE$survival.average.iid, function(iIID){iIID[,oorder.times,drop=0L]})
}else{
out$survival.average.iid <- outSE$survival.average.iid[,oorder.times,drop=0L]
}
}else {
out$survival.average.iid <- outSE$survival.average.iid
}
}
if(is.list(attr(average.iid,"factor"))){
if("hazard" %in% type){
names(out$hazard.average.iid) <- names(attr(average.iid,"factor"))
}
if("cumhazard" %in% type){
names(out$cumhazard.average.iid) <- names(attr(average.iid,"factor"))
}
if("survival" %in% type){
names(out$survival.average.iid) <- names(attr(average.iid,"factor"))
}
}
}
if((se+band)>0){
if ("cumhazard" %in% type){
if (needOrder && (diag[1] == FALSE)){
out$cumhazard.se <- outSE$cumhazard.se[,oorder.times,drop=0L]
}else{
out$cumhazard.se <- outSE$cumhazard.se
}
}
if ("survival" %in% type){
if (needOrder && (diag[1] == FALSE)){
out$survival.se <- outSE$survival.se[,oorder.times,drop=0L]
} else{
out$survival.se <- outSE$survival.se
}
}
}
}
add.list <- list(lastEventTime = etimes.max,
se = se,
band = band,
type = type,
diag = diag,
nTimes = nTimes,
baseline = FALSE,
var.lp = infoVar$lpvars.original,
var.strata = infoVar$stratavars.original)
if (keep.times==TRUE){
add.list$times <- times
}
if (is.strata[1] && keep.strata[1]==TRUE){
add.list$strata <- new.strata
}
if( keep.infoVar){
add.list$infoVar <- infoVar
}
all.covars <- c(infoVar$stratavars.original,infoVar$lpvars.original)
if( keep.newdata[1]==TRUE && length(all.covars)>0){
add.list$newdata <- newdata[, all.covars, with = FALSE]
}
out[names(add.list)] <- add.list
class(out) <- "predictCox"
if(confint){
out <- stats::confint(out)
}
if(band[1] && se[1]==FALSE){
out[paste0(type,".se")] <- NULL
}
if(band[1] && iid[1]==FALSE){
out[paste0(type,".iid")] <- NULL
}
return(out)
}
} |
BGC <- function(Data, Group, numc=NULL, ncomp=NULL, Scale=FALSE, graph=FALSE){
check(Data, Group)
if (is.data.frame(Data) == TRUE) {
Data=as.matrix(Data)
}
if(is.null(ncomp)) {ncomp=2}
if(is.null(colnames(Data))) {
colnames(Data) = paste('V', 1:ncol(Data), sep='')
}
if(is.null(ncomp)) {ncomp=2}
Group = as.factor(Group)
rownames(Data) = Group
M = length(levels(Group))
P = dim(Data)[2]
n = as.vector(table(Group))
N = sum(n)
split.Data = split(Data,Group)
if(is.null(numc)) {numc=min(M-1, P)}
for(m in 1:M){
split.Data[[m]] = matrix(split.Data[[m]], nrow=n[m])
split.Data[[m]] = scale(split.Data[[m]], center=TRUE, scale=Scale)
}
Con.Data = split.Data[[1]]
for(m in 2:M) {
Con.Data = rbind(Con.Data, split.Data[[m]])
}
rownames(Con.Data) = Group
colnames(Con.Data) = colnames(Data)
cov.Group = vector("list", M)
for(m in 1:M){
cov.Group[[m]] = t(split.Data[[m]]) %*% split.Data[[m]] / n[m]
}
res <- list(
Data = Data,
Con.Data = Con.Data,
split.Data = split.Data,
Group=Group)
L=vector("list",M)
for(m in 1:M){
SVD = svd(split.Data[[m]])
L[[m]] = SVD$v[,1:numc]
}
H = matrix(0,P,P)
for(m in 1:M){
H = H + L[[m]] %*% t(L[[m]])
}
W = eigen(H)$vectors[,1:ncomp]
res$loadings.common= W
rownames(res$loadings.common) = colnames(Data)
colnames(res$loadings.common) = paste("Dim", 1:ncomp, sep="")
lambda = matrix(0, nrow=M, ncol=ncomp)
for(m in 1:M){
lambda[m,] = round(diag(t(W) %*% cov.Group[[m]] %*% W),3)
}
res$lambda = lambda
rownames(res$lambda) = levels(Group)
colnames(res$lambda) = paste("Dim", 1:ncomp, sep="")
exp.var = matrix(0,M,ncomp)
for(m in 1:M){
exp.var[m,] = 100 * lambda[m,]/ sum(diag(cov.Group[[m]]))
}
res$exp.var = exp.var
rownames(res$exp.var) = levels(Group)
colnames(res$exp.var) = paste("Dim", 1:ncomp, sep="")
if(graph) {plot.mg(res)}
class(res) = c("BGC", "mg")
return(res)
}
print.BGC <- function(x, ...)
{
cat("\nBetween Group Comparison\n")
cat(rep("-",43), sep="")
cat("\n$loadings.common ", "common loadings")
cat("\n$Data ", "Data set")
cat("\n")
invisible(x)
}
|
tagAssert <- function(tag, type = NULL, class = NULL, allowUI = TRUE) {
if (!inherits(tag, "shiny.tag")) {
print(tag)
stop("Expected an object with class 'shiny.tag'.")
}
if (allowUI &&
(hasCssClass(tag, "shiny-html-output") ||
hasCssClass(tag, "shinydashboard-menu-output"))) {
return()
}
if (!is.null(type) && tag$name != type) {
stop("Expected tag to be of type ", type)
}
if (!is.null(class)) {
if (is.null(tag$attribs$class)) {
stop("Expected tag to have class '", class, "'")
} else {
tagClasses <- strsplit(tag$attribs$class, " ")[[1]]
if (!(class %in% tagClasses)) {
stop("Expected tag to have class '", class, "'")
}
}
}
}
hasCssClass <- function(tag, class) {
if (is.null(tag$attribs) || is.null(tag$attribs$class))
return(FALSE)
classes <- strsplit(tag$attribs$class, " +")[[1]]
return(class %in% classes)
}
validateTabName <- function(name) {
if (grepl(".", name, fixed = TRUE)) {
stop("tabName must not have a '.' in it.")
}
}
findAttribute <- function(x, attr, val) {
if (is.atomic(x)) return(FALSE)
if (!is.null(x$attribs[[attr]])) {
if (identical(x$attribs[[attr]], val)) return(TRUE)
else return(FALSE)
}
if (length(x$children) > 0) {
return(any(unlist(lapply(x$children, findAttribute, attr, val))))
}
return(FALSE)
}
"%OR%" <- function(a, b) if (!is.null(a)) a else b
dropNulls <- function(x) {
x[!vapply(x, is.null, FUN.VALUE = logical(1))]
}
validateStatus <- function(status) {
if (status %in% validStatuses) {
return(TRUE)
}
stop("Invalid status: ", status, ". Valid statuses are: ",
paste(validStatuses, collapse = ", "), ".")
}
validStatuses <- c("primary", "secondary", "info", "success", "warning", "danger")
validateNuance <- function(nuance) {
if (nuance %in% validNuances) {
return(TRUE)
}
stop("Invalid nuance: ", nuance, ". Valid nuances are: ",
paste(validNuances, collapse = ", "), ".")
}
validNuances <- c("gray-dark", "gray", "white")
validateColor <- function(color) {
if (color %in% validColors) {
return(TRUE)
}
stop("Invalid color: ", color, ". Valid colors are: ",
paste(validColors, collapse = ", "), ".")
}
validColors <- c("indigo", "lightblue", "navy", "purple", "fuchsia", "pink",
"maroon", "orange", "lime", "teal", "olive")
validateStatusPlus <- function(status) {
if (status %in% validStatusesPlus) {
return(TRUE)
}
stop("Invalid status: ", status, ". Valid statuses are: ",
paste(validStatusesPlus, collapse = ", "), ".")
}
validStatusesPlus <- c(validStatuses, validNuances, validColors)
rd_color_tag <- function(color, label = color) {
style <- sprintf(
"width:12px;height:12px;background:%s;border-radius:2px;display:inline-block;margin-right:5px;",
color
)
sprintf(
"\\ifelse{html}{\\out{<span style='%s'></span>%s}}{%s}",
style, label, label
)
}
tagInsertChild <- function(tag, child, position) {
tag$children <- append(tag$children, list(child), position - 1)
tag
}
validateBoxProps <- function(title, label, sidebar, dropdownMenu, status, gradient, collapsible,
collapsed, solidHeader, background, elevation, width) {
if (!is.null(status)) validateStatusPlus(status)
if (!is.null(background)) validateStatusPlus(background)
if (!collapsible & collapsed) {
stop("Cannot collapse a card that is not collapsible.")
}
if (!is.null(status) && !is.null(background) && !solidHeader) {
stop("solidHeader must be TRUE whenever background and status are not NULL at the same time.")
}
if (gradient && is.null(background)) stop("gradient cannot be used when background is NULL.")
if (!is.null(elevation)) {
stopifnot(is.numeric(elevation))
stopifnot(elevation < 6)
stopifnot(elevation >= 0)
}
if (!is.null(width)) {
stopifnot(is.numeric(width))
stopifnot(width <= 12)
stopifnot(width >= 0)
}
}
createBoxTools <- function(collapsible, collapsed, closable, maximizable,
sidebar, dropdownMenu, boxToolSize, status,
background, solidHeader) {
btnClass <- paste0(
"btn btn-tool",
if (!is.null(boxToolSize)) paste0(" btn-", boxToolSize)
)
if (is.null(status) && !is.null(background)) {
btnClass <- paste0(
btnClass,
if (background %in% validStatusesPlus) {
paste0(" bg-", background)
}
)
}
if (!is.null(status) && solidHeader) {
btnClass <- paste0(
btnClass,
if (status %in% validStatuses) {
paste0(" btn-", status)
}
)
}
collapseTag <- NULL
if (collapsible) {
collapseIcon <- if (collapsed)
"plus"
else "minus"
collapseTag <- shiny::tags$button(
class = btnClass,
type = "button",
`data-card-widget` = "collapse",
shiny::icon(collapseIcon)
)
}
closableTag <- NULL
if (closable) {
closableTag <- shiny::tags$button(
class = btnClass,
`data-card-widget` = "remove",
type = "button",
shiny::icon("times")
)
}
maximizableTag <- NULL
if (maximizable) {
maximizableTag <- shiny::tags$button(
type = "button",
class = btnClass,
`data-card-widget` = "maximize",
shiny::icon("expand")
)
}
sidebarToolTag <- NULL
if (!is.null(sidebar)) {
sidebar[[1]]$attribs$class <- btnClass
sidebarToolTag <- sidebar[[1]]
}
dropdownMenuToolTag <- NULL
if (!is.null(dropdownMenu)) {
dropdownMenu$children[[1]]$attribs$class <- paste0(btnClass, " dropdown-toggle")
dropdownMenuToolTag <- dropdownMenu
}
dropNulls(list(dropdownMenuToolTag, collapseTag, closableTag, maximizableTag, sidebarToolTag))
}
setBoxStyle <- function(height, sidebar) {
style <- NULL
if (!is.null(height)) {
style <- paste0("height: ", shiny::validateCssUnit(height))
}
if (!is.null(sidebar)) {
style <- paste0(style, "; padding: 10px;")
}
style
}
setBoxClass <- function(status, solidHeader, collapsible, collapsed,
elevation, gradient, background, sidebar) {
cardCl <- "card bs4Dash"
if (!is.null(status)) {
cardCl <- paste0(cardCl, " card-", status)
}
if (!solidHeader) cardCl <- paste0(cardCl, " card-outline")
if (collapsible && collapsed) cardCl <- paste0(cardCl, " collapsed-card")
if (!is.null(elevation)) cardCl <- paste0(cardCl, " elevation-", elevation)
if (!is.null(background)) {
cardCl <- paste0(cardCl, " bg-", if (gradient) "gradient-", background)
}
if (!is.null(sidebar)) {
sidebarToggle <- sidebar[[1]]
startOpen <- sidebarToggle$attribs$`data-start-open`
if (startOpen == "true") {
cardCl <- paste0(cardCl, " direct-chat direct-chat-contacts-open")
} else {
cardCl <- paste0(cardCl, " direct-chat")
}
}
cardCl
}
extractSocialItem <- function(items, isComment = TRUE) {
if (length(items) > 0) {
dropNulls(lapply(items, function(item) {
if (inherits(item, "list")) {
lapply(item, function(nested) {
cond <- if (isComment) {
inherits(nested, "card-comment")
} else {
!inherits(nested, "card-comment")
}
if (cond) nested
})
} else {
cond <- if (isComment) {
inherits(item, "card-comment")
} else {
!inherits(item, "card-comment")
}
if (cond) item
}
}))
} else {
NULL
}
}
randomInt <- function (min, max) {
if (missing(max)) {
max <- min
min <- 0
}
if (min < 0 || max <= min)
stop("Invalid min/max values")
min + sample(max - min, 1) - 1
}
.globals <- new.env(parent = emptyenv())
.globals$ownSeed <- NULL
withPrivateSeed <-function (expr) {
if (exists(".Random.seed", envir = .GlobalEnv, inherits = FALSE)) {
hasOrigSeed <- TRUE
origSeed <- .GlobalEnv$.Random.seed
}
else {
hasOrigSeed <- FALSE
}
if (is.null(.globals$ownSeed)) {
if (hasOrigSeed) {
rm(.Random.seed, envir = .GlobalEnv, inherits = FALSE)
}
}
else {
.GlobalEnv$.Random.seed <- .globals$ownSeed
}
on.exit({
.globals$ownSeed <- .GlobalEnv$.Random.seed
if (hasOrigSeed) {
.GlobalEnv$.Random.seed <- origSeed
} else {
rm(.Random.seed, envir = .GlobalEnv, inherits = FALSE)
}
httpuv::getRNGState()
})
expr
}
p_randomInt <- function (...) {
withPrivateSeed(randomInt(...))
}
markTabAsSelected <- function (x) {
attr(x, "selected") <- TRUE
x
}
`%OR%` <- function (x, y)
{
if (is.null(x) || isTRUE(is.na(x)))
y
else x
}
findAndMarkSelectedTab <- function (tabs, selected, foundSelected) {
tabs <- lapply(tabs, function(div) {
if (foundSelected || is.character(div)) {
}
else if (inherits(div, "shiny.navbarmenu")) {
res <- findAndMarkSelectedTab(div$tabs, selected,
foundSelected)
div$tabs <- res$tabs
foundSelected <<- res$foundSelected
}
else {
if (is.null(selected)) {
foundSelected <<- TRUE
div <- markTabAsSelected(div)
}
else {
tabValue <- div$attribs$`data-value` %OR% div$attribs$title
if (identical(selected, tabValue)) {
foundSelected <<- TRUE
div <- markTabAsSelected(div)
}
}
}
return(div)
})
return(list(tabs = tabs, foundSelected = foundSelected))
}
anyNamed <- function (x)
{
if (length(x) == 0)
return(FALSE)
nms <- names(x)
if (is.null(nms))
return(FALSE)
any(nzchar(nms))
}
buildTabset <- function (tabs, ulClass, textFilter = NULL, id = NULL, selected = NULL,
foundSelected = FALSE) {
res <- findAndMarkSelectedTab(tabs, selected, foundSelected)
tabs <- res$tabs
foundSelected <- res$foundSelected
if (!is.null(id))
ulClass <- paste(ulClass, "shiny-tab-input")
if (anyNamed(tabs)) {
nms <- names(tabs)
nms <- nms[nzchar(nms)]
stop("Tabs should all be unnamed arguments, but some are named: ",
paste(nms, collapse = ", "))
}
tabsetId <- p_randomInt(1000, 10000)
tabs <- lapply(seq_len(length(tabs)), buildTabItem, tabsetId = tabsetId,
foundSelected = foundSelected, tabs = tabs, textFilter = textFilter)
tabNavList <- shiny::tags$ul(class = ulClass, id = id, `data-tabsetid` = tabsetId,
lapply(tabs, "[[", 1))
tabContent <- shiny::tags$div(class = "tab-content", `data-tabsetid` = tabsetId,
lapply(tabs, "[[", 2))
list(navList = tabNavList, content = tabContent)
}
isTabSelected <- function (x) {
isTRUE(attr(x, "selected", exact = TRUE))
}
containsSelectedTab <- function (tabs) {
any(vapply(tabs, isTabSelected, logical(1)))
}
getIcon <- function (tab = NULL, iconClass = NULL) {
if (!is.null(tab))
iconClass <- tab$attribs$`data-icon-class`
if (!is.null(iconClass)) {
if (grepl("fa-", iconClass, fixed = TRUE)) {
iconClass <- paste(iconClass, "fa-fw")
}
shiny::icon(name = NULL, class = iconClass)
}
else NULL
}
navbarMenuTextFilter <- function (text) {
if (grepl("^\\-+$", text))
shiny::tags$li(class = "divider")
else shiny::tags$li(class = "dropdown-header", text)
}
buildTabItem <- function (index, tabsetId, foundSelected, tabs = NULL, divTag = NULL,
textFilter = NULL) {
divTag <- if (!is.null(divTag))
divTag
else tabs[[index]]
if (is.character(divTag) && !is.null(textFilter)) {
liTag <- textFilter(divTag)
divTag <- NULL
}
else if (inherits(divTag, "shiny.navbarmenu")) {
tabset <- buildTabset(divTag$tabs, "dropdown-menu", navbarMenuTextFilter,
foundSelected = foundSelected)
containsSelected <- containsSelectedTab(divTag$tabs)
liTag <- shiny::tags$li(class = paste0("dropdown", if (containsSelected)
" active"), shiny::tags$a(href = "
`data-toggle` = "dropdown", `data-value` = divTag$menuName,
getIcon(iconClass = divTag$iconClass), divTag$title,
shiny::tags$b(class = "caret")), tabset$navList)
divTag <- tabset$content$children
}
else {
tabId <- paste("tab", tabsetId, index, sep = "-")
liTag <- shiny::tags$li(shiny::tags$a(href = paste("
`data-toggle` = "tab", `data-value` = divTag$attribs$`data-value`,
getIcon(iconClass = divTag$attribs$`data-icon-class`),
divTag$attribs$title))
if (isTabSelected(divTag)) {
liTag$attribs$class <- "active"
divTag$attribs$class <- "tab-pane active"
}
divTag$attribs$id <- tabId
divTag$attribs$title <- NULL
}
return(list(liTag = liTag, divTag = divTag))
}
shinyDeprecated <- function (new = NULL, msg = NULL, old = as.character(sys.call(sys.parent()))[1L],
version = NULL)
{
if (getOption("shiny.deprecation.messages") %OR% TRUE ==
FALSE)
return(invisible())
if (is.null(msg)) {
msg <- paste(old, "is deprecated.")
if (!is.null(new)) {
msg <- paste(msg, "Please use", new, "instead.",
"To disable this message, run options(shiny.deprecation.messages=FALSE)")
}
}
if (!is.null(version)) {
msg <- paste0(msg, " (Last used in version ", version,
")")
}
message(msg)
}
bs3_tabsetPanel <- function (tabs, id = NULL, selected = NULL,
type = c("tabs", "pills", "hidden"))
{
if (!is.null(id))
selected <- shiny::restoreInput(id = id, default = selected)
type <- match.arg(type)
tabset <- buildTabset(tabs, paste0("nav nav-", type), NULL, id, selected)
first <- tabset$navList
second <- tabset$content
shiny::tags$div(class = "tabbable", first, second)
}
validateIcon <- function (icon)
{
if (is.null(icon) || identical(icon, character(0))) {
return(icon)
}
else if (inherits(icon, "shiny.tag") && icon$name == "i") {
return(icon)
}
else {
stop("Invalid icon. Use Shiny's 'icon()' function to generate a valid icon")
}
}
waiterShowOnLoad <- function(
html = waiter::spin_1(), color = "
){
html <- as.character(html)
html <- gsub("\n", "", html)
show <- sprintf(
"waiter.show({
id: null,
html: '%s',
color: '%s'
});",
html, color
)
shiny::HTML(sprintf("<script>%s</script>", show))
}
app_container <- function(url, deps = FALSE) {
req <- httr::GET(url)
show_app <- req$status_code == 200
if (show_app) {
device_tag <- shiny::div(
class="marvel-device ipad black",
shiny::div(class = "camera"),
shiny::div(
class = "screen",
shiny::tags$iframe(
width = "100%",
src = url,
allowfullscreen = "",
frameborder = "0",
scrolling = "yes",
height = "770px"
)
),
shiny::div(class = "home")
)
if (deps){
shiny::tagList(
shiny::tags$link(
rel = "stylesheet",
href = system.file("marvel-devices-css-1.0.0/devices.min.css", package = "bs4Dash"),
type = "text/css"
),
device_tag
)
} else {
device_tag
}
}
} |
groot <- function(S2, D2bool) {
if(is.na(S2)) return(NA)
if (D2bool) {
if (S2<0.5) {
return(NaN)
}
S2threshold <- (143 + 19*sqrt(57))/16
if (S2<S2threshold) {
machin <- (S2^2*(63 - 2*S2) + 3*sqrt(3)*sqrt(S2^3*(4 + (143 - 8*S2)*S2)))
machin <- machin^(1/3)
return((8*S2 - (2^(4/3)*(-3 + S2)*S2)/machin - 2^(2/3)*machin)/(6*S2))
}
theta <- acos(((63 - 2*S2)*S2^2)/(2*sqrt(((-3 + S2)*S2)^3)))
return(4/3 - (2*((-3 + S2)*S2)^(1/2)*cos(theta/3))/(3*S2))
} else {
return((1+2*S2-sqrt(1+8*S2))/(2*S2))
}
} |
vwBaseYear2015 <- read.delim(file='vwBaseYear2015.txt', comment.char=' |
deblank<-function(a)
{
b = a
for(i in 1:length(a) )
{
h = unlist( strsplit(a[i], split='') )
b[i] = paste(h[h!=' '], collapse='')
}
return( b)
} |
knitr::opts_chunk$set(
message = FALSE,
warning = FALSE,
error = FALSE,
tidy = FALSE,
cache = FALSE
)
suppressMessages(suppressWarnings(library(distcomp)))
dcWorkspace <- tempdir()
ignore <- distcompSetup(workspace = dcWorkspace,
ssl_verifyhost = 0L, ssl_verifypeer = 0L)
available <- availableComputations()
( computationNames <- names(available) )
svdDef <- data.frame(compType = "RankKSVD",
rank = 20L,
ncol = 20L,
id = "SVD",
stringsAsFactors = FALSE)
set.seed(12345)
nSites <- 3
siteData <- lapply(seq.int(nSites), function(i) matrix(rnorm(10000), ncol=20))
sites <- lapply(seq.int(nSites),
function(x) list(name = paste0("site", x),
worker = makeWorker(defn = svdDef, data = siteData[[x]])
))
master <- makeMaster(svdDef)
for (site in sites) {
master$addSite(name = site$name, worker = site$worker)
}
system.time(result <- master$run(max.iter = 10000))
full_data <- do.call(rbind, siteData)
full_svd <- svd(full_data)
d_table <- data.frame(truth = full_svd$d, distcomp = result$d)
knitr::kable(d_table)
norm(abs(result$v) - abs(full_svd$v), "F")
coxDef <- data.frame(compType = "StratifiedCoxModel",
formula = "Surv(time, censor) ~ age + becktota + ndrugfp1 + ndrugfp2 + ivhx3 + race + treat",
projectName = "STCoxTest",
projectDesc = "STCox Project Desc",
stringsAsFactors = FALSE)
siteDataFiles <- file.path(system.file("ex", package="distcomp"), c("uis-site1.csv", "uis-site2.csv"))
siteData <- lapply(siteDataFiles, read.csv)
sites <- lapply(seq_along(siteData),
function(x) list(name = paste0("site", x),
worker = makeWorker(defn = coxDef, data = siteData[[x]])
))
master <- makeMaster(coxDef)
for (site in sites) {
master$addSite(name = site$name, worker = site$worker)
}
result <- master$run()
print(master$summary(), digits = 4)
coxFit <- survival::coxph(formula=Surv(time, censor) ~ age + becktota + ndrugfp1 + ndrugfp2 +
ivhx3 + race + treat + strata(site),
data = rbind(siteData[[1]], siteData[[2]]))
summary(coxFit)$coefficients
sessionInfo() |
schedule <- function(timetable, values, period=Inf) {
stopifnot(is.numeric(c(timetable, period, values)))
stopifnot(!is.unsorted(timetable), all(period >= timetable),
timetable[length(timetable)] != timetable[1] + period)
stopifnot(length(timetable) == length(values))
stopifnot(length(timetable) >= 2)
stopifnot(all(values >= 0))
x <- list(
timetable = timetable,
values = replace(values, values == Inf, -1),
period = replace(period, period == Inf, -1),
n = length(timetable)
)
x$schedule <- if (x$period < 0) list(
init = if (x$timetable[1] == 0) x$values[1] else 0,
intervals = c(x$timetable[1], diff(x$timetable)),
values = x$values,
period = x$period
) else list(
init = if (x$timetable[1] == 0) x$values[1] else x$values[x$n],
intervals = c(x$timetable[1], diff(x$timetable),
x$timetable[1] + x$period - x$timetable[x$n]),
values = c(x$values, x$values[1]),
period = x$period
)
class(x) <- "schedule"
x
}
print.schedule <- function(x, ...) {
out <- format(c(x$timetable, x$values), justify="right")
timetable <- seq_along(x$timetable)
cat(paste0(
"schedule: period: ",
ifelse(x$period > 0, x$period, Inf), "\n",
"{ timetable: ", paste(out[timetable], collapse=" "), " }\n",
"{ values: ", paste(out[-timetable], collapse=" "), " }\n"
))
invisible(x)
} |
filter_groups <- function(ep,
groupCol = "intended_target_family",
assays = c("ACEA", "APR", "ATG",
"NVS", "OT",
"TOX21", "CEETOX", "CLD", "TANGUAY", "NHEERL_PADILLA", "NCCT",
"NHEERL_HUNTER", "NHEERL_NIS", "NHEERL_MED", "UPITT"),
remove_groups = c("Background Measurement","Undefined")){
possible_assays <- unique(end_point_info$assay_source_name)
match.arg(assays, possible_assays, several.ok = TRUE)
assay_source_name <- assay_component_endpoint_name <- ".dplyr"
ep <- ep[,c("assay_component_endpoint_name",groupCol,"assay_source_name")] %>%
rename(endPoint = assay_component_endpoint_name,
assaysFull = assay_source_name)
names(ep)[names(ep) == groupCol] <- "groupCol"
ep <- ep[(ep$assaysFull %in% assays),]
ep <- ep[!is.na(ep$groupCol),]
if(any(!is.na(remove_groups))){
if(any(remove_groups != "")){
ep <- ep[!(ep$groupCol) %in% remove_groups,]
}
}
return(ep)
} |
library(testthat)
library(shinyMobile)
test_check("shinyMobile") |
bs.design<-function(x, diff.ord, spline.degree, knots.no)
{
n<-length(x)
xl<-min(x)
xr<-max(x)
xmin<-xl-(xr-xl)/100
xmax<-xr+(xr-xl)/100
dx<-(xmax-xmin)/(knots.no-1)
knots<-seq(xmin-spline.degree*dx,xmax+spline.degree*dx,by=dx)
B<-splines::spline.des(knots,x,spline.degree+1)$design
knots<-knots[1:(knots.no+spline.degree-1)]
D<-diag(length(knots))
d<-min(diff.ord,spline.degree)
if(d<diff.ord) warning(paste("order of differences > degree of
splines:\n new order of differences=",d,"\n"))
if(d>0) {for(i in 1:d) D<-diff(D)}
B.unpen.fact<-rep(1,length(knots))
if(diff.ord>1) {for(i in 2:diff.ord)
B.unpen.fact<-cbind(B.unpen.fact,knots^(i-1)) }
B.unpen<-(B%*%B.unpen.fact)
B.pen <-B%*%t(D)%*%solve(D%*%t(D))
return(list(B=B, X=B.unpen, Z=B.pen))
}
est.bGAMM<-function(fix,add,rnd,data,lambda,family=gaussian(link = "identity"),control=list())
{
if(attr(terms(fix), "intercept")==0)
{
variables<-attr(terms(fix),"term.labels")
fix<- paste(rownames((attr(terms(fix),"factors")))[1],"~ +1",sep="")
for (ir in 1:length(variables))
fix <- paste(fix, variables[ir], sep="+")
fix <-formula(fix)
}
y <- model.response(model.frame(fix, data))
X <- model.matrix(fix, data)
X<-as.matrix(X)
lin.old<-dim(X)[2]
if(attr(terms(add), "intercept")==0)
{
variables<-attr(terms(add),"term.labels")
add<- paste(rownames((attr(terms(add),"factors")))[1],"~ +1",sep="")
for (ir in 1:length(variables))
add <- paste(add, variables[ir], sep="+")
add <-formula(add)
}
U <- model.matrix(add, data)
U<-U[,-1]
m.old<-dim(U)[2]
very.old.names<-attr(terms(fix),"term.labels")
factor.names<-character()
for (i in 1:length(very.old.names))
{
if (substr(very.old.names[i],1,9)=="as.factor")
factor.names<-c(factor.names,very.old.names[i])
}
factor.list<-list()
if(length(factor.names)>0)
{
spl<-strsplit(factor.names,"\\(")
categ.names<-character()
for(uz in 1:length(spl))
categ.names<-c(categ.names,spl[[uz]][2])
spl2<-strsplit(categ.names,"\\)")
categ.names2<-character()
for(uz in 1:length(spl2))
categ.names2<-c(categ.names2,spl2[[uz]])
factor.names<-categ.names2
for (i in 1:length(factor.names))
factor.list[[i]]<-levels(as.factor(data[,factor.names[i]]))
}
old.names<-attr(X,"dimnames")[[2]]
U.names<-attr(U,"dimnames")[[2]]
rndformula <- as.character(rnd)
trmsrnd <- terms(rnd[[1]])
newrndfrml <- "~ -1"
newrndfrml <- paste(newrndfrml, if(attr(trmsrnd, "intercept")) names(rnd)[1] else "", sep=" + ")
if(length(attr(trmsrnd, "variables"))>1)
{
newrndfrml <- paste(newrndfrml,
paste(sapply(attr(trmsrnd,"term.labels"), function(lbl){
paste(lbl, names(rnd)[1], sep=":")
}), collapse=" + "), sep="+") }
W_start <- model.matrix(formula(newrndfrml), data)
rnlabels<-terms(formula(newrndfrml))
random.labels<-attr(rnlabels,"term.labels")
k<-table(data[,colnames(data)==(names(rnd)[1])])
n<-length(k)
s<-dim(W_start)[2]/n
if(s>1)
{
W<-W_start[,seq(from=1,to=1+(s-1)*n,by=n)]
for (i in 2:n)
W<-cbind(W,W_start[,seq(from=i,to=i+(s-1)*n,by=n)])
}else{
W<-W_start
}
control<-do.call(bGAMMControl, control)
nbasis<-control$nbasis
diff.ord<-control$diff.ord
spline.degree<-control$spline.degree
knots.no<-nbasis-(spline.degree-2)
if(length(attr(trmsrnd,"factors"))!=0 && !is.element(colnames(attr(trmsrnd,"factors")),very.old.names))
stop("Use only fixed effects as random slopes!")
if(!is.null(control$add.fix) && !is.element(control$add.fix,U.names))
stop("Forced additive terms must be also part of the additive formula!")
if(!(diff.ord<spline.degree))
stop("Order of differences must be lower than degree of B-spline polynomials!")
print(paste("Iteration ", 1,sep=""))
nbasis.old<-nbasis
U.fix<-NULL
dim.U.fix<-0
if(!is.null(control$add.fix))
{
add.out<-!is.element(U.names,control$add.fix)
U.fix<-U[,!add.out]
U.fix<-as.matrix(U.fix)
colnames(U.fix)<-U.names[!add.out]
U.names<-U.names[add.out]
dim.U.fix<-dim(U.fix)[2]
U<-U[,add.out]
}
m<-dim(U)[2]
Basis<-list()
Phi<-list()
for (r in 1:m)
{
Basis[[r]]<-bs.design(U[,r],diff.ord=diff.ord,spline.degree=spline.degree,knots.no=knots.no)
Phi[[r]]<-cbind(Basis[[r]]$X[,-1],Basis[[r]]$Z)
colnames(Phi[[r]])<-paste(colnames(U)[r],rep(1:dim(Phi[[r]])[2],each=1), sep=".")
}
if(!is.null(U.fix))
{
Basis.fix<-list()
Phi.fix<-list()
for (rr in 1:dim.U.fix)
{
Basis.fix[[rr]]<-bs.design(U.fix[,rr],diff.ord=diff.ord,spline.degree=spline.degree,knots.no=knots.no)
Phi.fix[[rr]]<-cbind(Basis.fix[[rr]]$X[,-1],Basis.fix[[rr]]$Z)
colnames(Phi.fix[[rr]])<-paste(colnames(U.fix)[rr],rep(1:dim(Phi.fix[[rr]])[2],each=1), sep=".")
}
for (rr in 1:dim.U.fix)
X<-cbind(X,Phi.fix[[rr]])
}
lin<-dim(X)[2]
if(length(control$start)==0)
control$start<-c(rep(0,(lin+m*nbasis+n*s)))
if(length(control$q_start)==0)
{
control$q_start<-rep(0.1,s)
if(s>1)
control$q_start<-diag(control$q_start)
}
beta_null<-control$start[1:lin.old]
if(!is.null(U.fix))
beta_null<-c(beta_null,rep(0,dim.U.fix*nbasis))
ranef_null<-control$start[(lin.old+1):(lin.old+n*s)]
q_start<-control$q_start
k1<-rep(0,lin.old)
if(diff.ord>1)
{
k2<-c(rep(0,diff.ord-1),rep(1,ncol(Basis[[r]]$Z)))
}else{
k2<-rep(1,ncol(Basis[[r]]$Z))
}
k22<-rep(k2,dim.U.fix+1)
k3<-rep(0,s*n)
K<-lambda*diag(c(k1,k22,k3))
N<-length(y)
Z_fastalles<-X
lin0<-sum(beta_null!=0)
if(s==1)
{
Q_start<-diag(q_start^2,s)
p_start<-c(rep(0,lin0),rep((q_start^2)^(-1),n*s))
P_start<-diag(p_start)
}else{
Q_start<-q_start
P_start<-matrix(0,lin0+n*s,lin0+n*s)
for(jf in 1:n)
P_start[(lin0+(jf-1)*s+1):(lin0+jf*s),(lin0+(jf-1)*s+1):(lin0+jf*s)]<-chol2inv(chol(q_start))
}
if(lin>1)
{
Eta_start<-X%*%beta_null+W%*%ranef_null
}else{
Eta_start<-rep(beta_null,N)+W%*%ranef_null
}
D_start<-as.vector(family$mu.eta(Eta_start))
Mu_start<-as.vector(family$linkinv(Eta_start))
Sigma_start<-as.vector(family$variance(Mu_start))
W0_inv<-D_start*1/Sigma_start*D_start
Z_start<-cbind(X[,beta_null!=0],W)
M0<-Z_start%*%chol2inv(chol((t(Z_start)%*%(Z_start*W0_inv))+P_start))%*%t(Z_start*W0_inv)
Mu<-as.vector(family$linkinv(Eta_start))
for (r in 1:m)
Z_fastalles<-cbind(Z_fastalles,Phi[[r]])
Z_alles<-cbind(Z_fastalles,W)
Z_r<-list()
for (r in 1:m)
Z_r[[r]]<-cbind(X,Phi[[r]])
Z_r_gross<-list()
for (r in 1:m)
Z_r_gross[[r]]<-cbind(Z_r[[r]],W)
Sigma<-as.vector(family$variance(Mu))
if(control$overdispersion==T)
{
phi_start<-(sum((y-Mu)^2/Mu))/(N-sum(diag(M0)))
Sigma<-Sigma*phi_start
}
Delta<-matrix(0,control$steps,(lin+m*nbasis+s*n))
Standard<-array(0,c(control$steps,m,N))
Standard_ma<-list()
for (ijk in 1:m)
Standard_ma[[ijk]]<-as.numeric()
Delta[1,1:lin]<-beta_null
Delta[1,(lin+m*nbasis+1):(lin+m*nbasis+s*n)]<-t(ranef_null)
Delta_start<-Delta[1,]
IC<-matrix(0,nrow=control$steps,ncol=m)
IC_stop<-rep(0,control$steps)
komp<-rep(0,control$steps)
E<-diag(N)
M1<-list()
diag_H1<-rep(0,m)
FinalHat<-list()
phi<-rep(0,control$steps)
Q<-array(0,c(s,s,control$steps+1))
Q[,,1]<-Q_start
D<-as.vector(family$mu.eta(Eta_start))
Delta_r<-matrix(0,nrow=lin+nbasis+s*n,ncol=m)
Eta_r<-matrix(0,N,m)
Mu_r<-matrix(0,N,m)
grp<-rep(1,m*nbasis)
for (r in 2:m)
{
grp[((r-1)*nbasis+1):(r*nbasis)]<-r
}
if(s==1)
{
P_alles<-c(rep(0,lin+m*nbasis),rep((Q_start^(-1)),n*s))
P_alles<-diag(P_alles)
}else{
P_alles<-matrix(0,lin+m*nbasis+n*s,lin+m*nbasis+n*s)
for(jf in 1:n)
P_alles[(lin+m*nbasis+(jf-1)*s+1):(lin+m*nbasis+jf*s),(lin+m*nbasis+(jf-1)*s+1):(lin+m*nbasis+jf*s)]<-chol2inv(chol(Q_start))
}
score_alles<-t(Z_alles)%*%((y-Mu)*D*1/Sigma)
F_alles<-t(Z_alles)%*%(Z_alles*D*1/Sigma*D)+P_alles
l=1
for (r in 1:m)
{
Inv_r<-chol2inv(chol(F_alles[c(1:lin,(lin+(r-1)*nbasis+1):(lin+r*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s)),c(1:lin,(lin+(r-1)*nbasis+1):(lin+r*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s))]+K))
Delta_r[,r]<-Inv_r%*%score_alles[c(1:lin,(lin+(r-1)*nbasis+1):(lin+r*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s))]
Eta_r[,r]<-Eta_start+Z_r_gross[[r]]%*%Delta_r[,r]
Mu_r[,r]<-as.vector(family$linkinv(Eta_r[,r]))
M1[[r]]<-(Z_r_gross[[r]]*sqrt(Sigma*D*1/Sigma*D))%*%Inv_r%*%t(Z_r_gross[[r]]*sqrt(D*1/Sigma*D*1/Sigma))
diag_H1[r]<-sum(diag(M0+M1[[r]]%*%(E-M0)))
if (family$family=="poisson")
IC[1,r]<-sum(y*log(Mu_r[,r])-Mu_r[,r])
if (family$family=="binomial")
IC[1,r]<-sum(y*log(Mu_r[,r])+(1-y)*log(1-Mu_r[,r]))
if (family$family=="gaussian")
IC[1,r]<-sum(y*Mu_r[,r]-0.5*(Mu_r[,r]^2))
if (control$sel.method=="aic")
IC[1,r]<-(-IC[1,r])+diag_H1[r]
if (control$sel.method=="bic")
IC[1,r]<-(-IC[1,r])+0.5*diag_H1[r]*log(n)
}
mi_ic<-match(min(IC[1,]),IC[1,])
g<-c(rep(T,lin),grp==mi_ic,rep(T,s*n))
Delta_r[(lin+1):(lin+nbasis),mi_ic]<-control$nue*Delta_r[(lin+1):(lin+nbasis),mi_ic]
Delta[1,g]<-Delta[1,g]+t(Delta_r[,mi_ic])
Nue_ma<-c(rep(1,lin),rep(control$nue,nbasis),rep(1,s*n))
Uu<-(E-(cbind(Z_r[[mi_ic]],W)*sqrt(Sigma*D*1/Sigma*D))%*%(chol2inv(chol(F_alles[c(1:lin,(lin+(mi_ic-1)*nbasis+1):(lin+mi_ic*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s)),c(1:lin,(lin+(mi_ic-1)*nbasis+1):(lin+mi_ic*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s))]+K))*Nue_ma)%*%t(cbind(Z_r[[mi_ic]],W)*sqrt(D*1/Sigma*D*1/Sigma)))%*%(E-M0)
FinalHat[[1]]<-E-Uu
defre<-sum(diag(FinalHat[[1]]))
komp[1]<-mi_ic
X1<-cbind(X,Phi[[mi_ic]])
if(s==1)
{
PP<-rep((Q_start^(-1)),n*s)
PP<-diag(PP)
}else{
PP<-matrix(0,n*s,n*s)
for(jf in 1:n)
PP[((jf-1)*s+1):(jf*s),((jf-1)*s+1):(jf*s)]<-chol2inv(chol(Q_start))
}
k1a<-rep(0,lin.old)
if(diff.ord>1)
{
k2a<-c(rep(0,diff.ord-1),rep(1,ncol(Basis[[r]]$Z)))
}else{
k2a<-rep(1,ncol(Basis[[r]]$Z))
}
k22a<-rep(k2a,dim.U.fix+1)
KK<-lambda*diag(c(k1a,k22a))
R1<-chol2inv(chol((t(X1)%*%(X1*D*1/Sigma*D)+KK)-(t(X1)%*%(W*D*1/Sigma*D)%*%chol2inv(chol(t(W)%*%(W*D*1/Sigma*D)+PP))%*%t(t(X1)%*%(W*D*1/Sigma*D)))))
R2<-(t(X1*D*1/Sigma)-(t(X1)%*%(W*D*1/Sigma*D)%*%chol2inv(chol(t(W)%*%(W*D*1/Sigma*D)+PP)))%*%t(W*D*1/Sigma))
Q_mi<-control$nue*R1[(lin+1):(lin+nbasis),]%*%R2%*%(E-M0)
Eta<-Z_alles%*%Delta[1,]
Mu<-as.vector(family$linkinv(Eta))
Sigma<-as.vector(family$variance(Mu))
Standard_ma[[mi_ic]]<-Phi[[mi_ic]]%*%Q_mi
Standard[1,mi_ic,]<-sqrt(diag(Standard_ma[[mi_ic]]%*%t(Standard_ma[[mi_ic]]*Sigma)))
D<-as.vector(family$mu.eta(Eta))
if (control$method=="EM")
{
aktuell_vec<-!is.element(Delta[1,],0)
X_aktuell<-Z_alles[,aktuell_vec]
m_aktuell<- sum(is.element(1:m,komp))
if(s==1)
{
P_gross<-c(rep(0,lin+m_aktuell*nbasis),rep((Q_start^(-1)),n*s))
P_gross<-diag(P_gross)
}else{
P_gross<-matrix(0,lin+m_aktuell*nbasis+n*s,lin+m_aktuell*nbasis+n*s)
for(jf in 1:n)
P_gross[(lin+m_aktuell*nbasis+(jf-1)*s+1):(lin+m_aktuell*nbasis+jf*s),(lin+m_aktuell*nbasis+(jf-1)*s+1):(lin+m_aktuell*nbasis+jf*s)]<-chol2inv(chol(Q_start))
}
F_gross<-t(X_aktuell)%*%(X_aktuell*D*1/Sigma*D)+P_gross
k1<-rep(0,lin.old)
if(diff.ord>1)
{
k2<-c(rep(0,diff.ord-1),rep(1,ncol(Basis[[r]]$Z)))
}else{
k2<-rep(1,ncol(Basis[[r]]$Z))
}
k22<-rep(k2,dim.U.fix+m_aktuell)
k3<-rep(0,n*s)
K_gross<-lambda*diag(c(k1,k22,k3))
InvFisher<-chol2inv(chol(F_gross+K_gross))
Q1<-InvFisher[(lin+m_aktuell+1):(lin+m_aktuell+s),(lin+m_aktuell+1):(lin+m_aktuell+s)]+Delta[1,(lin+m+1):(lin+m+s)]%*%t(Delta[1,(lin+m+1):(lin+m+s)])
for (i in 2:n)
Q1<-Q1+InvFisher[(lin+m_aktuell+(i-1)*s+1):(lin+m_aktuell+i*s),(lin+m_aktuell+(i-1)*s+1):(lin+m_aktuell+i*s)]+Delta[1,(lin+m+(i-1)*s+1):(lin+m+i*s)]%*%t(Delta[1,(lin+m+(i-1)*s+1):(lin+m+i*s)])
Q1<-1/n*Q1
}else{
Eta_tilde<-Eta+(y-Mu)*1/D
Betadach<-Delta[1,1:(lin+m*nbasis)]
aktuell_vec<-!is.element(Delta[1,1:(lin+m*nbasis)],0)
X_aktuell<-Z_fastalles[,aktuell_vec]
if(s==1)
{
optim.obj<-nlminb(sqrt(Q_start),likelihood_bobyqa,D=D,Sigma=Sigma,X=Z_fastalles,X_aktuell=X_aktuell,Eta_tilde=Eta_tilde,n=n,Betadach=Betadach,W=W, model="no.model", lower = 1e-14, upper = 20)
Q1<-as.matrix(optim.obj$par)^2
}else{
q_start_vec<-c(diag(q_start),q_start[lower.tri(q_start)])
up1<-min(20,50*max(q_start_vec))
upp<-rep(up1,length(q_start_vec))
low<-c(rep(0,s),rep(-up1,0.5*(s^2-s)))
kkk_vec<-c(rep(-1,s),rep(0.5,0.5*(s^2-s)))
optim.obj<-try(bobyqa(q_start_vec,likelihood,D=D,Sigma=Sigma,X=Z_fastalles,X_aktuell=X_aktuell,Eta_tilde=Eta_tilde,n=n,s=s,k=k,Betadach=Betadach,W=W, model="no.model", lower=low,upper=upp))
Q1<-matrix(0,s,s)
Q1[lower.tri(Q1)]<-optim.obj$par[(s+1):(s*(s+1)*0.5)]
Q1<-Q1+t(Q1)
diag(Q1)<-(optim.obj$par[1:s])
for (ttt in 0:100)
{
Q1[lower.tri(Q1)]<-((0.5)^ttt)*Q1[lower.tri(Q1)]
Q1[upper.tri(Q1)]<-((0.5)^ttt)*Q1[upper.tri(Q1)]
Q_solvetest<-try(solve(Q1))
if(all (eigen(Q1)$values>0) & class(Q_solvetest)[1]!="try-error")
break
}
}}
if (family$family=="poisson")
IC_stop[1]<-sum(y*log(Mu)-Mu)
if (family$family=="binomial")
IC_stop[1]<-sum(y*log(Mu)+(1-y)*log(1-Mu))
if (family$family=="gaussian")
IC_stop[1]<-sum(y*Mu-0.5*(Mu^2))
if (control$sel.method=="aic")
IC_stop[1]<-(-IC_stop[1])+defre
if (control$sel.method=="bic")
IC_stop[1]<-(-IC_stop[1])+0.5*defre*log(n)
if(control$overdispersion==T)
{
phi[1]<-(sum((y-Mu)^2/Mu))/(N-defre)
Sigma<-Sigma*phi[1]
}
Q[,,2]<-Q1
if(control$steps!=1)
{
for (l in 2:control$steps)
{
print(paste("Iteration ", l,sep=""))
if(s==1)
{
P_alles<-c(rep(0,lin+m*nbasis),rep((Q1^(-1)),n*s))
P_alles<-diag(P_alles)
}else{
P_alles<-matrix(0,lin+m*nbasis+n*s,lin+m*nbasis+n*s)
for(jf in 1:n)
P_alles[(lin+m*nbasis+(jf-1)*s+1):(lin+m*nbasis+jf*s),(lin+m*nbasis+(jf-1)*s+1):(lin+m*nbasis+jf*s)]<-chol2inv(chol(Q1))
}
score_alles<-t(Z_alles)%*%((y-Mu)*D*1/Sigma)
F_alles<-t(Z_alles)%*%(Z_alles*D*1/Sigma*D)+P_alles
for (r in 1:m)
{
if(r==1)
Inv_r<-chol2inv(chol(F_alles[c(1:lin,(lin+(r-1)*nbasis+1):(lin+r*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s)),c(1:lin,(lin+(r-1)*nbasis+1):(lin+r*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s))]+K))
Delta_r[,r]<-Inv_r%*%score_alles[c(1:lin,(lin+(r-1)*nbasis+1):(lin+r*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s))]
Eta_r[,r]<-Eta_start+Z_r_gross[[r]]%*%Delta_r[,r]
Mu_r[,r]<-as.vector(family$linkinv(Eta_r[,r]))
M1[[r]]<-(Z_r_gross[[r]]*sqrt(Sigma*D*1/Sigma*D))%*%Inv_r%*%t(Z_r_gross[[r]]*sqrt(D*1/Sigma*D*1/Sigma))
diag_H1[r]<-sum(diag(E-((E-M1[[r]])%*%Uu)))
if (family$family=="poisson")
IC[l,r]<-sum(y*log(Mu_r[,r])-Mu_r[,r])
if (family$family=="binomial")
IC[l,r]<-sum(y*log(Mu_r[,r])+(1-y)*log(1-Mu_r[,r]))
if (family$family=="gaussian")
IC[l,r]<-sum(y*Mu_r[,r]-0.5*(Mu_r[,r]^2))
if (control$sel.method=="aic")
IC[l,r]<-(-IC[l,r])+diag_H1[r]
if (control$sel.method=="bic")
IC[l,r]<-(-IC[l,r])+0.5*diag_H1[r]*log(n)
}
mi_ic<-match(min(IC[l,]),IC[l,])
g<-c(rep(T,lin),grp==mi_ic,rep(T,s*n))
Delta[l,]<-Delta[l-1,]
Delta_r[(lin+1):(lin+nbasis),mi_ic]<-control$nue*Delta_r[(lin+1):(lin+nbasis),mi_ic]
Delta[l,g]<-Delta[l,g]+t(Delta_r[,mi_ic])
komp[l]<-mi_ic
Uu<-(E-(cbind(Z_r[[mi_ic]],W)*sqrt(Sigma*D*1/Sigma*D))%*%(chol2inv(chol(F_alles[c(1:lin,(lin+(mi_ic-1)*nbasis+1):(lin+mi_ic*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s)),c(1:lin,(lin+(mi_ic-1)*nbasis+1):(lin+mi_ic*nbasis),(lin+m*nbasis+1):(lin+m*nbasis+n*s))]+K))*Nue_ma)%*%t(cbind(Z_r[[mi_ic]],W)*sqrt(D*1/Sigma*D*1/Sigma)))%*%(E-M0)
FinalHat[[l]]<-E-Uu
defre<-sum(diag(FinalHat[[l]]))
X1<-cbind(X,Phi[[mi_ic]])
if(s==1)
{
PP<-rep((Q1^(-1)),n*s)
PP<-diag(PP)
}else{
PP<-matrix(0,n*s,n*s)
for(jf in 1:n)
PP[((jf-1)*s+1):(jf*s),((jf-1)*s+1):(jf*s)]<-chol2inv(chol(Q1))
}
R1<-chol2inv(chol((t(X1)%*%(X1*D*1/Sigma*D)+KK)-(t(X1)%*%(W*D*1/Sigma*D)%*%chol2inv(chol(t(W)%*%(W*D*1/Sigma*D)+PP))%*%t(t(X1)%*%(W*D*1/Sigma*D)))))
R2<-(t(X1*D*1/Sigma)-(t(X1)%*%(W*D*1/Sigma*D)%*%chol2inv(chol(t(W)%*%(W*D*1/Sigma*D)+PP)))%*%t(W*D*1/Sigma))
Q_mi<-control$nue*R1[(lin+1):(lin+nbasis),]%*%R2%*%(E-FinalHat[[l-1]])
if(is.matrix(Standard_ma[[mi_ic]]))
{
Standard_ma[[mi_ic]]<-Standard_ma[[mi_ic]]+Phi[[mi_ic]]%*%Q_mi
}else{
Standard_ma[[mi_ic]]<-Phi[[mi_ic]]%*%Q_mi
}
Eta<-Z_alles%*%Delta[l,]
Mu<-as.vector(family$linkinv(Eta))
Sigma<-as.vector(family$variance(Mu))
for(jh in as.numeric(levels(as.factor(komp[1:l])))[as.numeric(levels(as.factor(komp[1:l])))!=0])
Standard[l,jh,]<-sqrt(diag(Standard_ma[[jh]]%*%t(Standard_ma[[jh]]*Sigma)))
D<-as.vector(family$mu.eta(Eta))
if (control$method=="EM")
{
aktuell_vec<-!is.element(Delta[l,],0)
X_aktuell<-Z_alles[,aktuell_vec]
m_aktuell<- sum(is.element(1:m,komp))
if(s==1)
{
P_gross<-c(rep(0,lin+m_aktuell*nbasis),rep((Q1^(-1)),n*s))
P_gross<-diag(P_gross)
}else{
P_gross<-matrix(0,lin+m_aktuell*nbasis+n*s,lin+m_aktuell*nbasis+n*s)
for(jf in 1:n)
P_gross[(lin+m_aktuell*nbasis+(jf-1)*s+1):(lin+m_aktuell*nbasis+jf*s),(lin+m_aktuell*nbasis+(jf-1)*s+1):(lin+m_aktuell*nbasis+jf*s)]<-chol2inv(chol(Q1))
}
F_gross<-t(X_aktuell)%*%(X_aktuell*D*1/Sigma*D)+P_gross
k22<-rep(k2,dim.U.fix+m_aktuell)
k3<-rep(0,n*s)
K_gross<-lambda*diag(c(k1,k22,k3))
InvFisher<-chol2inv(chol(F_gross+K_gross))
Q1<-InvFisher[(lin+m_aktuell+1):(lin+m_aktuell+s),(lin+m_aktuell+1):(lin+m_aktuell+s)]+Delta[l,(lin+m+1):(lin+m+s)]%*%t(Delta[l,(lin+m+1):(lin+m+s)])
for (i in 2:n)
Q1<-Q1+InvFisher[(lin+m_aktuell+(i-1)*s+1):(lin+m_aktuell+i*s),(lin+m_aktuell+(i-1)*s+1):(lin+m_aktuell+i*s)]+Delta[l,(lin+m+(i-1)*s+1):(lin+m+i*s)]%*%t(Delta[l,(lin+m+(i-1)*s+1):(lin+m+i*s)])
Q1<-1/n*Q1
}else{
Eta_tilde<-Eta+(y-Mu)*1/D
Betadach<-Delta[l,1:(lin+m*nbasis)]
aktuell_vec<-!is.element(Delta[l,1:(lin+m*nbasis)],0)
X_aktuell<-Z_fastalles[,aktuell_vec]
if(s==1)
{
optim.obj<-try(nlminb(sqrt(Q1),likelihood_bobyqa,D=D,Sigma=Sigma,X=Z_fastalles,X_aktuell=X_aktuell,Eta_tilde=Eta_tilde,n=n,Betadach=Betadach,W=W, model="no.model", lower = 1e-12, upper = 20))
Q1<-as.matrix(optim.obj$par)^2
}else{
Q1_vec<-c(diag(Q1),Q1[lower.tri(Q1)])
optim.obj<-try(bobyqa(Q1_vec,likelihood,D=D,Sigma=Sigma,X=Z_fastalles,X_aktuell=X_aktuell,Eta_tilde=Eta_tilde,n=n,s=s,k=k,Betadach=Betadach,W=W, model="no.model", lower=low,upper=upp))
Q1<-matrix(0,s,s)
Q1[lower.tri(Q1)]<-optim.obj$par[(s+1):(s*(s+1)*0.5)]
Q1<-Q1+t(Q1)
diag(Q1)<-(optim.obj$par[1:s])
for (ttt in 0:100)
{
Q1[lower.tri(Q1)]<-((0.5)^ttt)*Q1[lower.tri(Q1)]
Q1[upper.tri(Q1)]<-((0.5)^ttt)*Q1[upper.tri(Q1)]
Q_solvetest<-try(solve(Q1))
if(all (eigen(Q1)$values>0) & class(Q_solvetest)[1]!="try-error")
break
}
}}
if (family$family=="poisson")
IC_stop[l]<-sum(y*log(Mu)-Mu)
if (family$family=="binomial")
IC_stop[l]<-sum(y*log(Mu)+(1-y)*log(1-Mu))
if (family$family=="gaussian")
IC_stop[l]<-sum(y*Mu-0.5*(Mu^2))
if (control$sel.method=="aic")
IC_stop[l]<-(-IC_stop[l])+defre
if (control$sel.method=="bic")
IC_stop[l]<-(-IC_stop[l])+0.5*defre*log(n)
if(control$overdispersion==T)
{
phi[l]<-(sum((y-Mu)^2/Mu))/(N-defre)
Sigma<-Sigma*phi[l]
}
Q[,,l+1]<-Q1
kritval<-sqrt(sum((Delta[l-1,]-Delta[l,])^2))/sqrt(sum(Delta[l,]^2))
if(kritval<1e-8)
break
kritval2<-abs(IC_stop[l-1]-IC_stop[l])/abs(IC_stop[l])
if(kritval2<1e-8)
break
}}
if (l<control$steps)
{
for (wj in (l+1):control$steps)
{
Delta[wj,]<-Delta[l,]
Q[,,wj+1]<-Q1
IC[wj,]<-IC[l,]
IC_stop[wj]<-IC_stop[l]
}}
opt<-match(min(IC_stop),IC_stop)
if (control$OPT==TRUE)
{
Delta_neu<-Delta[opt,]
}else{
Delta_neu<-Delta[l,]
}
Eta_opt<-Z_alles%*%Delta_neu
Mu_opt<-as.vector(family$linkinv(Eta_opt))
Sigma_opt<-as.vector(family$variance(Mu_opt))
D_opt<-as.vector(family$mu.eta(Eta_opt))
aktuell_vec<-!is.element(Delta_neu,0)
X_aktuell<-Z_alles[,aktuell_vec]
m_aktuell<- sum(is.element(1:m,komp[1:opt]))
k1b<-rep(0,lin.old)
if(diff.ord>1)
{
k2b<-c(rep(0,diff.ord-1),rep(1,ncol(Basis[[r]]$Z)))
}else{
k2b<-rep(1,ncol(Basis[[r]]$Z))
}
k22b<-rep(k2b,dim.U.fix+m_aktuell)
k3b<-rep(0,n*s)
K_opt<-lambda*diag(c(k1b,k22b,k3b))
if(s==1)
{
P_opt<-c(rep(0,lin+m_aktuell*nbasis),rep((Q[,,opt+1]^(-1)),n*s))
P_opt<-diag(P_opt)
}else{
P_opt<-matrix(0,lin+m_aktuell*nbasis+n*s,lin+m_aktuell*nbasis+n*s)
for(jf in 1:n)
P_opt[(lin+m_aktuell*nbasis+(jf-1)*s+1):(lin+m_aktuell*nbasis+jf*s),(lin+m_aktuell*nbasis+(jf-1)*s+1):(lin+m_aktuell*nbasis+jf*s)]<-chol2inv(chol(Q[,,opt+1]))
}
F_opt<-t(X_aktuell)%*%(X_aktuell*D_opt*1/Sigma_opt*D_opt)+P_opt
Inv_F_opt<-chol2inv(chol(F_opt+K_opt))
Lin_errors<-sqrt(diag(Inv_F_opt))
Standard_errors<-list()
Standard_errors$smooth<-Standard[opt,,]
rownames(Standard_errors$smooth)<-U.names
if(!is.null(U.fix))
{
Standard_errors$smooth.fix<-matrix(0,dim.U.fix,N)
for (uz in 1:dim.U.fix)
Standard_errors$smooth.fix[uz,]<-sqrt(diag(Phi.fix[[uz]]%*%Inv_F_opt[(lin.old+1):lin,(lin.old+1):lin]%*%t(Phi.fix[[uz]])))
Standard_errors$smooth<-rbind(Standard_errors$smooth.fix,Standard_errors$smooth)
rownames(Standard_errors$smooth)[1:dim.U.fix]<-colnames(U.fix)
}
Standard_errors$fixef<-Lin_errors[1:lin.old]
Standard_errors$ranef<-Lin_errors[(lin+m_aktuell*nbasis+1):(lin+m_aktuell*nbasis+n*s)]
y_dach<-as.vector(family$linkinv(Eta_opt))
if(s==1)
{
Qfinal<-sqrt(Q[,,opt+1])
}else{
Qfinal<-Q[,,opt+1]
}
if(!is.matrix(Qfinal))
Qfinal<-as.matrix(Qfinal)
colnames(Qfinal)<-random.labels
rownames(Qfinal)<-random.labels
names(Delta_neu)[1:lin.old]<-colnames(X)[1:lin.old]
if(!is.null(U.fix))
{
U.fix.names<-character()
for (rr in 1:dim.U.fix)
U.fix.names<-c(U.fix.names,colnames(Phi.fix[[rr]]))
names(Delta_neu)[(lin.old+1):lin]<-U.fix.names
}
U.long.names<-character()
for (r in 1:m)
U.long.names<-c(U.long.names,colnames(Phi[[r]]))
names(Delta_neu)[(lin+1):(lin+m*nbasis)]<-U.long.names
names(Delta_neu)[(lin+m*nbasis+1):(lin+m*nbasis+n*s)]<-colnames(W)
comp<-character()
for(oi in 1:length(komp))
comp<-c(comp,U.names[komp[oi]])
ret.obj=list()
ret.obj$IC<-IC
ret.obj$IC_sel<-IC_stop
ret.obj$opt<-opt
ret.obj$Deltamatrix<-Delta
ret.obj$ranef<-Delta_neu[(lin+m*nbasis+1):(lin+m*nbasis+n*s)]
ret.obj$coefficients<-Delta_neu[1:(lin.old)]
ret.obj$spline.weights<-Delta_neu[(lin.old+1):(lin+m*nbasis)]
ret.obj$fixerror<-Standard_errors$fixef
ret.obj$ranerror<-Standard_errors$ranef
ret.obj$smootherror<-Standard_errors$smooth
ret.obj$lambda<-lambda
ret.obj$components<-comp
ret.obj$Q_long<-Q
ret.obj$Q<-Qfinal
ret.obj$y_hat<-Mu_opt
ret.obj$HatMatrix<-FinalHat[[opt]]
ret.obj$phi<-phi[opt]
ret.obj$family<-family
ret.obj$fix<-fix
ret.obj$add<-add
ret.obj$newrndfrml<-newrndfrml
ret.obj$subject<-names(rnd)[1]
ret.obj$data<-data
ret.obj$U<-cbind(U.fix,U)
ret.obj$U.fix.names<-colnames(U.fix)
ret.obj$nbasis<-nbasis
ret.obj$spline.degree<-spline.degree
ret.obj$diff.ord<-diff.ord
ret.obj$factor.names<-factor.names
ret.obj$factor.list<-factor.list
return(ret.obj)
}
bGAMM <- function(fix=formula, add=formula, rnd=formula, data, lambda, family=NULL, control=list()) UseMethod("bGAMM")
bGAMM.formula <- function(fix,add,rnd,...)
{
est <- est.bGAMM(fix,add,rnd,...)
est$fitted.values <- est$y_hat
est$StdDev <- est$Q
est$call <- match.call()
class(est) <- "bGAMM"
est
}
print.bGAMM <- function(x, ...)
{
cat("Call:\n")
print(x$call)
cat("\nFixed Effects:\n")
cat("\nCoefficients:\n")
print(x$coefficients)
cat("\nForced Smooth Effects:\n")
print(x$U.fix.names)
cat("\nSelected Smooth Effects:\n")
print(levels(as.factor(x$comp)))
cat("\nRandom Effects:\n")
cat("\nStdDev:\n")
print(x$StdDev)
}
summary.bGAMM <- function(object, ...)
{
se <- object$fixerror
zval <- coefficients(object) / se
TAB <- cbind(Estimate = coefficients(object),
StdErr = se,
z.value = zval,
p.value = 2*pnorm(-abs(zval)))
res <- list(call=object$call,
coefficients=TAB,StdDev=object$StdDev, comp=object$comp,U.fix.names=object$U.fix.names)
class(res) <- "summary.bGAMM"
res
}
print.summary.bGAMM <- function(x, ...)
{
cat("Call:\n")
print(x$call)
cat("\n")
cat("\nFixed Effects:\n")
cat("\nCoefficients:\n")
printCoefmat(x$coefficients, P.values=TRUE, has.Pvalue=TRUE)
cat("\nForced Smooth Effects:\n")
print(x$U.fix.names)
cat("\nSelected Smooth Effects:\n")
print(levels(as.factor(x$comp)))
cat("\nRandom Effects:\n")
cat("\nStdDev:\n")
print(x$StdDev)
}
predict.bGAMM <- function(object,newdata=NULL,...)
{
if(is.null(newdata))
{
y<-fitted(object)
}else{
nbasis<-object$nbasis
diff.ord<-object$diff.ord
spline.degree<-object$spline.degree
knots.no<-nbasis-(spline.degree-2)
if(length(object$factor.names>0))
{
for (i in 1:length(object$factor.names))
{
newdata[,object$factor.names[i]]<-factor(newdata[,object$factor.names[i]],levels=object$factor.list[[i]])
}}
X <- model.matrix(object$fix, newdata)
U <- model.matrix(object$add, newdata)
U<-U[,-1]
if(length(object$U.fix.names)>0)
{
reord<-is.element(colnames(U),object$U.fix.names)
U<-cbind(U[,reord],U[,!reord])
}
m<-dim(U)[2]
Basis<-list()
Phi<-numeric()
for (r in 1:m)
{
Basis[[r]]<-bs.design(U[,r],diff.ord=diff.ord,spline.degree=spline.degree,knots.no=knots.no)
Phi<-cbind(Phi,Basis[[r]]$X[,-1],Basis[[r]]$Z)
}
subj.new<-levels(as.factor(newdata[,object$subject]))
subj.old<-levels(as.factor(object$data[,object$subject]))
subj.test<-is.element(subj.new,subj.old)
subj.ok<-subj.new[subj.test]
krit.random<-!all(!is.element(subj.new,subj.old))
if(krit.random)
{
W_start <- model.matrix(formula(object$newrndfrml), newdata)
}else{
W_start <- NULL
}
rnlabels<-terms(formula(object$newrndfrml))
random.labels<-attr(rnlabels,"term.labels")
s<-length(random.labels)
k<-table(newdata[,colnames(newdata)==(object$subject)])
n<-length(k)
if(s>1)
{for (i in 2:s)
subj.test<-cbind(subj.test,subj.test)
subj.test<-as.vector(t(subj.test))
}
if(krit.random)
{
if(s>1)
{
W<-W_start[,seq(from=1,to=1+(s-1)*n,by=n)]
for (i in 2:n)
W<-cbind(W,W_start[,seq(from=i,to=i+(s-1)*n,by=n)])
}else{
W<-W_start
}
y<- as.vector(object$family$linkinv(cbind(X,Phi)%*%c(object$coef,object$spline.weights)))
rand.ok<-is.element(newdata[,object$subject],subj.ok)
W.neu<-W[,subj.test]
y[rand.ok]<- object$family$linkinv(cbind(X,Phi,W.neu)[rand.ok,]%*%c(object$coef,object$spline.weights,object$ranef[match(colnames(W.neu),names(object$ranef))]))
}else{
W<-NULL
y<- as.vector(object$family$linkinv(cbind(X,Phi)%*%c(object$coef,object$spline.weights)))
}
}
y
}
plot.bGAMM <- function(x,which=NULL,...)
{
U<-x$U
m<-dim(U)[2]
if(is.null(which))
which<-1:m
p<-length(which)
if(p>9)
stop("Too many smooth functions! Please specify at maximum nine.")
a<-ceiling(sqrt(p))
b<-floor(sqrt(p))
if(b==0)
b<-1
nbasis<-x$nbasis
diff.ord<-x$diff.ord
spline.degree<-x$spline.degree
knots.no<-nbasis-(spline.degree-2)
spline.ma<-list()
Design<-list()
smooth.ma<-matrix(0,m,dim(U)[1])
smootherror<-x$smootherror
for(i in which)
{
spline.ma[[i]]<-bs.design(sort(U[,i]), diff.ord=diff.ord, spline.degree=spline.degree, knots.no=knots.no)
smootherror[i,]<-x$smootherror[i,order(U[,i])]
Design[[i]]<-cbind(spline.ma[[i]]$X[,-1],spline.ma[[i]]$Z)
smooth.ma[i,]<-Design[[i]]%*%x$spline.weights[((i-1)*nbasis+1):(i*nbasis)]
}
smoothlow<-smooth.ma-2*smootherror
smoothupp<-smooth.ma+2*smootherror
par(mfrow=c(a,b))
for(i in which)
{
plot(sort(U[,i]), smooth.ma[i,], type = "l", lwd=2, xlab=paste(colnames(U)[i]),ylab="",main=" ",cex.lab=2,cex.axis=2,ylim=c(min(smoothlow[i,])-0.1*(max(smoothlow[i,])-min(smoothlow[i,])),max(smoothupp[i,])+0.1*(max(smoothlow[i,])-min(smoothlow[i,]))))
lines(sort(U[,i]),smoothlow[i,], type = "l",lty=2, lwd=2)
lines(sort(U[,i]),smoothupp[i,], type = "l",lty=2, lwd=2)
rug(jitter(U[,i]))
}
} |
REB2m2<-function(andar,cbaixo,cand,nand,m2and,m2apt){
if(andar<=nand)
if(nand<9){
custo = cbaixo+cand*nand
custop = cbaixo+cand*andar
for (i in 1:nand) {
x=(cbaixo+cand*i)
}
for (i in 1:nand) {
x[i]=(cbaixo+cand*i)
}
sum=sum(x)
resultado=m2apt*(custop+((custop-custop*m2and)/m2and)+((custo-sum)/(m2and*nand)))
return(resultado)
}
else{
print("nand non debe superar 9")
}
else{
print("O nivel do andar non pode ser maior que nand")
}
} |
source("ESEUR_config.r")
library("coin")
est=read.csv(paste0(ESEUR_dir, "group-compare/simula_04.csv.xz"), as.is=TRUE)
A=subset(est, Group == "A")$Estimate
centered=data.frame(est=A-mean(A), group="A")
B=subset(est, Group == "B")$Estimate
centered=rbind(centered, data.frame(est=B-mean(B), group="B"))
ansari_test(est ~ as.factor(group), data=centered)
ansari_test(Estimate ~ as.factor(Group), data=est) |
CompareSplits <- function (splits, splits2) {
splits <- as.Splits(splits)
splits2 <- as.Splits(splits2, splits)
nTip <- attr(splits, 'nTip')
splits <- unique(WithoutTrivialSplits(splits, nTip))
splits2 <- unique(WithoutTrivialSplits(splits2, nTip))
duplicates <- in.Splits(splits, splits2)
nSplits <- length(splits)
nSplits2 <- length(splits2)
nTotal <- nSplits + nSplits2
nBoth <- sum(duplicates)
incompatibles <- !CompatibleSplits(splits, splits2)
if (length(incompatibles) > 0) {
d1 <- sum(apply(incompatibles, 1, any))
d2 <- sum(apply(incompatibles, 2, any))
} else {
d1 <- d2 <- 0
}
c(N = nTotal, P1 = nSplits, P2 = nSplits2, s = nBoth,
d1 = d1, d2 = d2,
r1 = nSplits - nBoth - d1, r2 = nSplits2 - nBoth - d2)
}
CompareBipartitions <- CompareSplits
SplitStatus <- function (trees, cf = trees[[1]]) {
compareWithFirst <- identical(cf, trees[[1]])
if (!compareWithFirst) trees <- UnshiftTree(cf, trees)
treeStats <- NTip(trees)
if (length(unique(treeStats)) > 1) {
stop("All trees must have the same number of tips")
}
splits <- as.Splits(trees)
ret <- vapply(splits, CompareSplits, splits2 = splits[[1]], double(8))
if (compareWithFirst) t(ret) else t(ret[, -1])
}
BipartitionStatus <- SplitStatus
SharedSplitStatus <- function (trees, cf) UseMethod('SharedSplitStatus')
SharedSplitStatus.list <- function (trees, cf = trees[[1]]) {
t(vapply(trees, PairSharedSplitStatus, cf = cf,
c(N = 0L, P1 = 0L, P2 = 0L, s = 0L,
d1 = 0L, d2 = 0L, r1 = 0L, r2 = 0L)))
}
SharedSplitStatus.multiPhylo <- SharedSplitStatus.list
SharedSplitStatus.phylo <- function (trees, cf = trees) {
PairSharedSplitStatus(trees, cf)
}
SharedBipartitionStatus <- SharedSplitStatus
PairSharedSplitStatus <- function (ref, cf) {
refTips <- ref$tip.label
cfTips <- cf$tip.label
prunedRef <- drop.tip(ref, setdiff(refTips, cfTips))
prunedCf <- drop.tip(cf, setdiff(cfTips, refTips))
refSplits <- as.Splits(prunedRef)
cfSplits <- as.Splits(prunedCf, prunedRef)
CompareSplits(refSplits, cfSplits)
} |
list_depth <- function(List) {
ifelse(is.list(List), 1L + max(sapply(List, list_depth)), 0L)
} |
test.Rhat <- function(samples,cutoff,params.omit,verbose=TRUE){
params <- colnames(samples[[1]])
expand <- sapply(strsplit(params, "\\["), "[", 1)
gd <- function(hold){
r <- try(gelman.diag(hold, autoburnin=FALSE)$psrf[1], silent=TRUE)
if(inherits(r, "try-error") || !is.finite(r)) {
r <- NA
}
return(r)
}
failure <- FALSE
index <- 1
while (failure==FALSE && index <= length(params)){
if(!expand[index]%in%params.omit){
test <- gd(samples[,index])
} else {test <- 1}
if(is.na(test)){test <- 1}
if(test>cutoff){failure=TRUE
} else {index <- index + 1}
}
if(failure==TRUE&verbose){
cat('.......Convergence check failed for parameter \'',params[index],'\'\n',sep="")
}
if(failure==FALSE&verbose){
cat('.......All parameters converged.','\n\n')
}
return(failure)
} |
yx_ssp.f <-
function(x, x.grd, y.grd, ...){
ssp = smooth.spline(x.grd, y.grd)
return(predict(ssp, x)$y)
} |
.lmFit <- function (y, X) {
n <- length(x = y)
X1 <- stats::model.matrix(~. , as.data.frame(X))
mod <- stats::lm(y ~ X1 - 1)
res <- residuals(object = mod)
s2 <- sum(res^2)
P0 <- diag(x = n) - X1 %*% solve(a = crossprod(x = X1), b = t(x = X1))
return( list("P0" = P0, "res" = res, "s2" = s2) )
} |
centerDataTwoGroupsByModelSelection <- function(
X, group.one.indices, group.two.indices, within.group.indices) {
n1 <- length(group.one.indices)
n2 <- length(group.two.indices)
if ((n1 == 1) | (n2 == 1)) {
stop("current implementation does not work for n1 = 1 or n2 = 1")
}
n <- n1 + n2
stopifnot(n == nrow(X))
m <- ncol(X)
if (length(within.group.indices) != 0) {
stopifnot(max(within.group.indices) <= m)
}
colCen.indices <- setdiff(1:m, within.group.indices)
X.cen <- matrix(NA, nrow=n, ncol=m)
X.cen[, colCen.indices] <- scale(X[, colCen.indices], center=TRUE,
scale=FALSE)
X.cen[group.one.indices, within.group.indices] <- scale(
X[group.one.indices, within.group.indices], scale=FALSE)
X.cen[group.two.indices, within.group.indices] <- scale(
X[group.two.indices, within.group.indices], scale=FALSE)
return(X.cen)
} |
context("CJS")
test_that("markCJS",{
data<-simdataCJS(delta_1=1,delta_2=0)$Enc.Mat
expect_error(markCJS(data,iter=10,burnin=0),NA)
expect_error(markCJS(data,mod.phi=~age,iter=10,burnin=0,parameters=list(Phi=list(age.bins=c(0,1,4))),right=FALSE),NA)
})
test_that("multimarkCJS",{
expect_error(multimarkCJS(Enc.Mat=bobcat,data.type="never",iter=10,burnin=0),NA)
expect_error(multimarkCJS(Enc.Mat=bobcat,mod.phi=~age,iter=10,burnin=0,parameters=list(Phi=list(age.bins=c(0,1,7))),right=FALSE),NA)
expect_error(getprobsCJS(multimarkCJS(Enc.Mat=bobcat,data.type="never",iter=10,burnin=0)),NA)
setup<-processdata(bobcat)
expect_error(test.dot<-multimarkCJS(mms=setup,parms="all",iter=10,burnin=0),NA)
expect_error(multimodelCJS(modlist=list(mod1=test.dot,mod2=test.dot)),NA)
}) |
pdf("reg-tests-2.pdf", encoding = "ISOLatin1.enc")
options(stringsAsFactors=FALSE)
options(useFancyQuotes=FALSE)
for(m in 1:5) {
cat("\n",m,":\n")
print(as.vector(abbreviate(state.name, minl=m)))
}
x <- cbind(x1 = 3, x2 = c(4:1, 2:5))
dimnames(x)[[1]] <- letters[1:8]
apply(x, 2, summary)
apply(x, 1, quantile)
d.arr <- 2:5
arr <- array(1:prod(d.arr), d.arr,
list(NULL,letters[1:d.arr[2]],NULL,paste("V",4+1:d.arr[4],sep="")))
aa <- array(1:20,c(2,2,5))
str(apply(aa[FALSE,,,drop=FALSE], 1, dim))
stopifnot(
apply(arr, 1:2, sum) == t(apply(arr, 2:1, sum)),
aa == apply(aa,2:3,function(x) x),
all.equal(apply(apply(aa,2:3, sum),2,sum),
10+16*0:4, tolerance = 4*.Machine$double.eps)
)
marg <- list(1:2, 2:3, c(2,4), c(1,3), 2:4, 1:3, 1:4)
for(m in marg) print(apply(arr, print(m), sum))
for(m in marg)
print(dim(apply(arr, print(m), quantile, names=FALSE)) == c(5,d.arr[m]))
nus <- c(0:5,10,20)
x0 <- 2^(-20:10)
plot(x0,x0, log='xy', ylab="", ylim=c(.1,1e60),type='n',
main = "Bessel Functions -Y_nu(x) near 0\n log - log scale")
for(nu in sort(c(nus,nus+.5))) lines(x0, -besselY(x0,nu=nu), col = nu+2)
legend(3,1e50, leg=paste("nu=", paste(nus,nus+.5, sep=",")), col=nus+2, lwd=1)
x <- seq(3,500);yl <- c(-.3, .2)
plot(x,x, ylim = yl, ylab="",type='n', main = "Bessel Functions Y_nu(x)")
for(nu in nus){xx <- x[x > .6*nu]; lines(xx,besselY(xx,nu=nu), col = nu+2)}
legend(300,-.08, leg=paste("nu=",nus), col = nus+2, lwd=1)
x <- seq(10,50000,by=10);yl <- c(-.1, .1)
plot(x,x, ylim = yl, ylab="",type='n', main = "Bessel Functions Y_nu(x)")
for(nu in nus){xx <- x[x > .6*nu]; lines(xx,besselY(xx,nu=nu), col = nu+2)}
summary(bY <- besselY(2,nu = nu <- seq(0,100,len=501)))
which(bY >= 0)
summary(bY <- besselY(2,nu = nu <- seq(3,300,len=51)))
summary(bI <- besselI(x = x <- 10:700, 1))
set.seed(123)
L3 <- LETTERS[1:3]
d <- data.frame(cbind(x=1, y=1:10), fac = sample(L3, 10, replace=TRUE),
stringsAsFactors=TRUE)
str(d)
(d0 <- d[, FALSE])
(d.0 <- d[FALSE, ])
(d00 <- d0[FALSE,])
stopifnot(identical(d, cbind(d, d0)),
identical(d, cbind(d0, d)))
stopifnot(identical(d, rbind(d,d.0)),
identical(d, rbind(d.0,d)),
identical(d, rbind(d00,d)),
identical(d, rbind(d,d00)))
diag(array(1:4, dim=5))
diag(0)
z <- matrix(0, 0, 4)
diag(z)
diag(z) <- numeric(0)
z
zz <- data.frame(a=I("abc"), b=I("def\"gh"))
format(zz)
for(i in c(1:5,10,15,16)) cat(i,":\t",format(pi,digits=i),"\n")
p <- c(47,13,2,.1,.023,.0045, 1e-100)/1000
format.pval(p)
format.pval(p / 0.9)
format.pval(p / 0.9, dig=3)
x <- c(100,-1e-13,Inf,-Inf, NaN, pi, NA)
x
names(x) <- formatC(x, dig=3)
is.finite(x)
is.na(x)
which(is.na(x) & !is.nan(x))
is.na(x) | is.finite(x)
is.infinite(x)
all(is.na(x) != is.finite(x) | is.infinite(x))
all(is.nan(x) != is.finite(x) | is.infinite(x))
(ix <- structure(as.integer(x),names= names(x)))
all(is.na(ix) != is.finite(ix) | is.infinite(ix))
storage.mode(ii <- -3:5)
storage.mode(zm <- outer(ii,ii, FUN="*"))
storage.mode(zd <- outer(ii,ii, FUN="/"))
range(zd, na.rm=TRUE)
zd[,ii==0]
(storage.mode(print(1:1 / 0:0)))
(storage.mode(print(1:1 / 1:1)))
(storage.mode(print(1:1 + 1:1)))
(storage.mode(print(2:2 * 2:2)))
fred <- matrix(1:12, 3, 4, dimnames=list(LETTERS[1:3], LETTERS[4:7]))
bill <- c("happy" = 100, "sad" = 1000)
kronecker(fred, bill, make.dimnames = TRUE)
bill <- outer(bill, c("cat"=3, "dog"=4))
kronecker(fred, bill, make.dimnames = TRUE)
dimnames(bill) <- NULL
kronecker(fred, bill, make=TRUE)
kronecker(bill, fred, make=TRUE)
dim(bill) <- c(2, 2, 1)
dimnames(bill) <- list(c("happy", "sad"), NULL, "")
kronecker(fred, bill, make=TRUE)
bill <- array(1:24, c(3, 4, 2))
dimnames(bill) <- list(NULL, NULL, c("happy", "sad"))
kronecker(bill, fred, make=TRUE)
kronecker(fred, bill, make=TRUE)
fred <- outer(fred, c("frequentist"=4, "bayesian"=4000))
kronecker(fred, bill, make=TRUE)
authors <- data.frame(
surname = c("Tukey", "Venables", "Tierney", "Ripley", "McNeil"),
nationality = c("US", "Australia", "US", "UK", "Australia"),
deceased = c("yes", rep("no", 4)), stringsAsFactors=TRUE)
books <- data.frame(
name = c("Tukey", "Venables", "Tierney",
"Ripley", "Ripley", "McNeil", "R Core"),
title = c("Exploratory Data Analysis",
"Modern Applied Statistics ...",
"LISP-STAT",
"Spatial Statistics", "Stochastic Simulation",
"Interactive Data Analysis",
"An Introduction to R"),
other.author = c(NA, "Ripley", NA, NA, NA, NA,
"Venables & Smith"),
stringsAsFactors=TRUE)
b2 <- books; names(b2)[1] <- names(authors)[1]
merge(authors, b2, all.x = TRUE)
merge(authors, b2, all.y = TRUE)
merge(authors, b2[7,])
merge(authors, b2[7,], all.y = TRUE)
merge(authors, b2[7,], all.x = TRUE)
is.na(c(1,NA))
is.na(paste(c(1,NA)))
is.na(list())
ll <- list(pi,"C",NaN,Inf, 1:3, c(0,NA), NA)
is.na (ll)
lapply(ll, is.nan)
ll <- list(list(1))
for (i in 1:5) print(as.integer(is.na(ll)))
tm <- matrix(c(2,1,0,1,0,NA,NA,NA,0), nrow=3)
scale(tm, , FALSE)
scale(tm)
tabulate(numeric(0))
z <- ts(matrix(1:300, 100, 3), start = c(1961, 1), frequency = 12)
stopifnot(z == z)
stopifnot(z-z == 0)
if(FALSE)
tools::assertWarning(matrix(1:90, 10, 3), verbose=TRUE)
ts(1:5, start=2, end=4)
ts(1:5, start=3, end=17)
l <- list(a=10)
attr(l$a, "xx") <- 23
l
m <- matrix(c(1, 2, 3, 0, 10, NA), 3, 2)
na.omit(m)
x <- 1
attr(x, "foo") <- list(a="a")
x
test.list <- list(A = list(formula=Y~X, subset=TRUE),
B = list(formula=Y~X, subset=TRUE))
test.list
summary(attenu)
summary(attenu, digits = 5)
summary(data.matrix(attenu), digits = 5)
set.seed(1)
x <- c(round(runif(10), 2), 10000)
summary(x)
summary(data.frame(x))
detg1 <-
structure(list(Temp = factor(c(2L, 1L, 2L, 1L, 2L, 1L, 2L,
1L, 2L, 1L, 2L, 1L), labels = c("High", "Low")),
M.user = factor(c(1L, 1L, 2L, 2L, 1L, 1L, 2L, 2L, 1L,
1L, 2L, 2L), labels = c("N", "Y")),
Soft = factor(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 3L, 3L, 3L, 3L),
labels = c("Hard", "Medium", "Soft")),
M = c(42, 30, 52, 43,
50, 23, 55, 47, 53, 27, 49, 29), X = c(68, 42, 37, 24, 66,
33, 47, 23, 63, 29, 57, 19)), names = c("Temp", "M.user",
"Soft", "M", "X"), class = "data.frame", row.names = c("1", "3",
"5", "7", "9", "11", "13", "15", "17", "19", "21", "23"))
detg1.m0 <- glm(cbind(X,M)~1,binomial,detg1)
detg1.m0
step(detg1.m0,scope=list(upper=~M.user*Temp*Soft))
temp <- matrix(1:4, 2)
all.vars(temp ~ 3)
all.vars(temp[1, ] ~ 3)
gofX.df<-
structure(list(A = c(0.696706709347165, 0.362357754476673,
-0.0291995223012888,
0.696706709347165, 0.696706709347165, -0.0291995223012888, 0.696706709347165,
-0.0291995223012888, 0.362357754476673, 0.696706709347165, -0.0291995223012888,
0.362357754476673, -0.416146836547142, 0.362357754476673, 0.696706709347165,
0.696706709347165, 0.362357754476673, -0.416146836547142, -0.0291995223012888,
-0.416146836547142, 0.696706709347165, -0.416146836547142, 0.362357754476673,
-0.0291995223012888), B = c(0.717356090899523, 0.932039085967226,
0.999573603041505, 0.717356090899523, 0.717356090899523, 0.999573603041505,
0.717356090899523, 0.999573603041505, 0.932039085967226, 0.717356090899523,
0.999573603041505, 0.932039085967226, 0.909297426825682, 0.932039085967226,
0.717356090899523, 0.717356090899523, 0.932039085967226, 0.909297426825682,
0.999573603041505, 0.909297426825682, 0.717356090899523, 0.909297426825682,
0.932039085967226, 0.999573603041505), C = c(-0.0291995223012888,
-0.737393715541246, -0.998294775794753, -0.0291995223012888,
-0.0291995223012888, -0.998294775794753, -0.0291995223012888,
-0.998294775794753, -0.737393715541246, -0.0291995223012888,
-0.998294775794753, -0.737393715541246, -0.653643620863612, -0.737393715541246,
-0.0291995223012888, -0.0291995223012888, -0.737393715541246,
-0.653643620863612, -0.998294775794753, -0.653643620863612,
-0.0291995223012888,
-0.653643620863612, -0.737393715541246, -0.998294775794753),
D = c(0.999573603041505, 0.67546318055115, -0.0583741434275801,
0.999573603041505, 0.999573603041505, -0.0583741434275801,
0.999573603041505, -0.0583741434275801, 0.67546318055115,
0.999573603041505, -0.0583741434275801, 0.67546318055115,
-0.756802495307928, 0.67546318055115, 0.999573603041505,
0.999573603041505, 0.67546318055115, -0.756802495307928,
-0.0583741434275801, -0.756802495307928, 0.999573603041505,
-0.756802495307928, 0.67546318055115, -0.0583741434275801
), groups = factor(c(1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L,
2L, 2L, 2L, 2L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L),
labels = c("1", "2", "3"))),
names = c("A", "B", "C", "D", "groups"), row.names = 1:24,
class = "data.frame")
gofX.manova <- manova(formula = cbind(A, B, C, D) ~ groups, data = gofX.df)
try(summary(gofX.manova))
z <- as.matrix(t(trees))
z[1,1] <- z[2,2] <- z[3,3] <- z[2,4] <- NA
dist(z, method="euclidean")
dist(z, method="maximum")
dist(z, method="manhattan")
dist(z, method="canberra")
kernel("daniell", m=5)
kernel("modified.daniell", m=5)
kernel("daniell", m=c(3,5,7))
(tt <- ts(1:10, start = c(1920,7), end = c(1921,4), freq = 12))
cbind(tt, tt + 1)
try(cov(rnorm(10), NULL))
try(cor(rnorm(10), NULL))
a <- matrix(c("axx","b","c","d","e","f","g","h"), nrow=2)
format(a)
format(a, justify="right")
res <- svd(rbind(1:7))
if(res$u[1,1] < 0) {res$u <- -res$u; res$v <- -res$v}
res
g1 <- function(fitted) { on.exit(remove(fitted)); return(function(foo) foo) }
g2 <- function(fitted) { on.exit(remove(fitted)); function(foo) foo }
f <- function(g) { fitted <- 1; h <- g(fitted); print(fitted)
ls(envir=environment(h)) }
f(g1)
f(g2)
f2 <- function()
{
g.foo <- g1
g.bar <- g2
g <- function(x,...) UseMethod("g")
fitted <- 1; class(fitted) <- "foo"
h <- g(fitted); print(fitted); print(ls(envir=environment(h)))
fitted <- 1; class(fitted) <- "bar"
h <- g(fitted); print(fitted); print(ls(envir=environment(h)))
invisible(NULL)
}
f2()
g <- function() as.environment(-1)
f <- function(x) UseMethod("f")
f.foo <- function(x) { on.exit(e <<- g()); NULL }
f.bar <- function(x) { on.exit(e <<- g()); return(NULL) }
f(structure(1,class = "foo"))
ls(env = e)
f(structure(1,class = "bar"))
stopifnot("x" == ls(env = e))
oldCon <- options("contrasts")
y <- rnorm(10)
x <- rep(c(TRUE, FALSE), 5)
model.matrix(y ~ x)
lm(y ~ x)
DF <- data.frame(x, y)
lm(y ~ x, data=DF)
options(contrasts=c("contr.helmert", "contr.poly"))
model.matrix(y ~ x)
lm(y ~ x, data=DF)
z <- 1:10
lm(y ~ x*z)
lm(y ~ x*z - 1)
options(oldCon)
x <- ts(1:10)
diffinv(diff(x),xi=x[1])
diffinv(diff(x,lag=1,differences=2),lag=1,differences=2,xi=x[1:2])
as.numeric(as.character(NaN))
as.numeric(as.character(Inf))
rowsum(matrix(1:12, 3,4), c("Y","X","Y"))
x <- y <- unlist(as.list(
parse(text=paste("\"\\", as.character(as.octmode(1:255)), "\"",sep=""))))
save(x, ascii=TRUE, file=(fn <- tempfile(tmpdir = getwd())))
load(fn)
all(x==y)
unlink(fn)
zz <- file("all.Rout", open="wt")
sink(zz)
sink(zz, type="message")
try(log("a"))
sink(type="message")
sink()
try(log("a"))
zz <- file("all.Rout", open="wt")
sink(zz)
sink(zz, type="message")
try(log("a"))
closeAllConnections()
(foo <- showConnections())
stopifnot(nrow(foo) == 0)
try(log("a"))
unlink("all.Rout")
x <- c(TRUE, FALSE, TRUE, TRUE)
mean(x)
mean(as.factor(x))
z <- table(x = 1:2, y = 1:2)
z - 1
unclass(z - 1)
ctl <- c(4.17,5.58,5.18,6.11,4.50,4.61,5.17,4.53,5.33,5.14)
trt <- c(4.81,4.17,4.41,3.59,5.87,3.83,6.03,4.89,4.32,4.69)
group <- gl(2,10,20, labels = c("Ctl","Trt"))
weight <- c(ctl, trt)
data <- data.frame(weight, group)
fit <- lm(cbind(w=weight, w2=weight^2) ~ group, data=data)
predict(fit, newdata=data[1:2, ])
lab <- dimnames(HairEyeColor)
HairEye <- cbind(expand.grid(Hair=lab$Hair, Eye=lab$Eye, Sex=lab$Sex,
stringsAsFactors = TRUE),
Fr = as.vector(HairEyeColor))
HairEye.fit <- glm(Fr ~ . ^2, poisson, HairEye)
drop1(HairEye.fit)
m <- list(a1=1:3, a2=4:6, a3=pi, a4=c("a","b","c"))
dim(m) <- c(2,2)
m
m[,2]
m[2,2]
m <- list(a1=1:3, a2=4:6, a3=pi, a4=c("a","b","c"))
matrix(m, 2, 2)
x <- vector("list",6)
dim(x) <- c(2,3)
x[1,2] <- list(letters[10:11])
x
m <- list(as.integer(1), pi, 3+5i, "testit", TRUE, factor("foo"))
dim(m) <- c(1, 6)
m
for(type in c("Wichmann-Hill", "Marsaglia-Multicarry", "Super-Duper",
"Mersenne-Twister", "Knuth-TAOCP", "Knuth-TAOCP-2002"))
{
set.seed(123, type)
print(RNGkind())
runif(100); print(runif(4))
set.seed(1000, type)
runif(100); print(runif(4))
set.seed(77, type)
runif(100); print(runif(4))
}
RNGkind(normal.kind = "Kinderman-Ramage")
set.seed(123)
RNGkind()
rnorm(4)
RNGkind(normal.kind = "Ahrens-Dieter")
set.seed(123)
RNGkind()
rnorm(4)
RNGkind(normal.kind = "Box-Muller")
set.seed(123)
RNGkind()
rnorm(4)
set.seed(123)
runif(4)
set.seed(123, "default")
set.seed(123, "Marsaglia-Multicarry")
runif(4)
d.df <- data.frame(x = 1:3, y = c("A","D","E"), z = c(6,9,10))
merge(d.df[1,], d.df)
f <- factor(c("a","b"))
levels(f) <- list(C="C", A="a", B="b")
f
(x <- factor(c("a", "NA", "b"), exclude=NULL))
is.na(x)[3] <- TRUE
x
(x <- c("a", "NA", NA, "b"))
print(x, quote = FALSE)
paste(x)
format(x)
format(x, justify = "right")
format(x, justify = "none")
x <- 1:20
tt1 <- ts(x,start=c(1960,2), freq=12)
tt2 <- ts(10+x,start=c(1960,2), freq=12)
cbind(tt1, tt2)
x <- c(0.35, 0.64, 0.12, 1.66, 1.52, 0.23, -1.99, 0.42, 1.86, -0.02,
-1.64, -0.46, -0.1, 1.25, 0.37, 0.31, 1.11, 1.65, 0.33, 0.89,
-0.25, -0.87, -0.22, 0.71, -2.26, 0.77, -0.05, 0.32, -0.64, 0.39,
0.19, -1.62, 0.37, 0.02, 0.97, -2.62, 0.15, 1.55, -1.41, -2.35,
-0.43, 0.57, -0.66, -0.08, 0.02, 0.24, -0.33, -0.03, -1.13, 0.32,
1.55, 2.13, -0.1, -0.32, -0.67, 1.44, 0.04, -1.1, -0.95, -0.19,
-0.68, -0.43, -0.84, 0.69, -0.65, 0.71, 0.19, 0.45, 0.45, -1.19,
1.3, 0.14, -0.36, -0.5, -0.47, -1.31, -1.02, 1.17, 1.51, -0.33,
-0.01, -0.59, -0.28, -0.18, -1.07, 0.66, -0.71, 1.88, -0.14,
-0.19, 0.84, 0.44, 1.33, -0.2, -0.45, 1.46, 1, -1.02, 0.68, 0.84)
y <- c(1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,
1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1,
1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0)
try(glm(y ~ x, family = poisson(identity)))
glm(y ~ x, family = poisson(identity), start = c(1,0))
set.seed(123)
y <- rpois(100, pmax(3*x, 0))
glm(y ~ x, family = poisson(identity), start = c(1,0))
warnings()
x <- y <- LETTERS[1:2]
x[5] <- "C"
length(y) <- 5
x
y
oldcon <- options(contrasts = c("contr.helmert", "contr.poly"))
U <- gl(3, 6, 18, labels=letters[1:3])
V <- gl(3, 2, 18, labels=letters[1:3])
A <- rep(c(0, 1), 9)
B <- rep(c(1, 0), 9)
set.seed(1); y <- rnorm(18)
terms(y ~ A:U + A:V - 1)
lm(y ~ A:U + A:V - 1)$coefficients
lm(y ~ (A + B) : (U + V) - 1)
options(oldcon)
(qq <- sapply(0:5, function(k) {
x <- c(rep(-Inf,k+1), 0:k, rep(Inf, k))
sapply(1:9, function(typ)
quantile(x, pr=(2:10)/10, type=typ))
}, simplify="array"))
x <- c(-Inf, -Inf, Inf, Inf)
median(x)
quantile(x)
z <- matrix(1:9, 3, 3)
dimnames(z) <- list(c("x", "y", NA), c(1, NA, 3))
z
r <- c(10,23,23,26,17,5,53,55,32,46,10,8,10,8,23,0,3,22,15,32,3)
n <- c(39,62,81,51,39,6,74,72,51,79,13,16,30,28,45,4,12,41,30,51,7)
trt <- factor(rep(1:4,c(5,6,5,5)))
Y <- r/n
z <- aov(Y ~ trt, weights=n)
test <- as.data.frame(matrix(1:25, 5, 5))
test1 <- matrix(-(1:10), 2, 5)
rbind(test, test1)
rbind(test1, test)
x <- "\\abc\\"
names(x) <- 1
x
print(x, quote=FALSE)
x <- data.frame(1:10)
x$z <- data.frame(x=1:10,yyy=11:20)
summary(x)
form <- formula(y ~ a + b:c + d + e + e:d)
(tt <- terms(form))
(tt2 <- terms(formula(tt)))
stopifnot(identical(tt, tt2))
terms(delete.response(tt))
terms(breaks ~ ., data = warpbreaks)
terms(breaks ~ . - tension, data = warpbreaks)
terms(breaks ~ . - tension, data = warpbreaks, simplify = TRUE)
terms(breaks ~ . ^2, data = warpbreaks)
terms(breaks ~ . ^2, data = warpbreaks, simplify = TRUE)
(x <- structure(1:4, other=as.factor(LETTERS[1:3])))
TEMP <- data.frame(VAR1=c(1,2,3,4,5), VAR2=c(5,4,3,2,1), VAR3=c(1,1,1,1,NA))
TEMP[,c(1,3)][TEMP[,c(1,3)]==1 & !is.na(TEMP[,c(1,3)])] < -10
TEMP
relrange <- function(x) {
r <- range(x)
diff(r)/max(abs(r))/.Machine$double.eps
}
x <- c(0.12345678912345678,
0.12345678912345679,
0.12345678912345676)
plot(x)
y <- c(0.9999563255363383973418,
0.9999563255363389524533,
0.9999563255363382863194)
plot(y)
set.seed(101)
par(mfrow = c(3,3))
for(j.fac in 1e-12* c(10, 1, .7, .3, .2, .1, .05, .03, .01)) {
x <- pi + jitter(numeric(101), f = j.fac)
rrtxt <- paste("rel.range =", formatC(relrange(x), dig = 4),"* EPS")
cat("j.f = ", format(j.fac)," ; ", rrtxt,"\n",sep="")
plot(x, type = "l", main = rrtxt)
cat("par(\"usr\")[3:4]:", formatC(par("usr")[3:4], wid = 10),"\n",
"par(\"yaxp\") : ", formatC(par("yaxp"), wid = 10),"\n\n", sep="")
}
par(mfrow = c(1,1))
"cement" <-
structure(list(x1 = c(7, 1, 11, 11, 7, 11, 3, 1, 2, 21, 1, 11, 10),
x2 = c(26, 29, 56, 31, 52, 55, 71, 31, 54, 47, 40, 66, 68),
x3 = c(6, 15, 8, 8, 6, 9, 17, 22, 18, 4, 23, 9, 8),
x4 = c(60, 52, 20, 47, 33, 22, 6, 44, 22, 26, 34, 12, 12),
y = c(78.5, 74.3, 104.3, 87.6, 95.9, 109.2, 102.7, 72.5,
93.1, 115.9, 83.8, 113.3, 109.4)),
names = c("x1", "x2", "x3", "x4", "y"), class = "data.frame",
row.names = 1:13)
teststep <- function(formula, data)
{
d2 <- data
fit <- lm(formula, data=d2)
step(fit)
}
teststep(formula(y ~ .), cement)
str(array(1))
(tf <- table(ff <- factor(c(1:2,NA,2), exclude=NULL)))
identical(levels(ff), dimnames(tf)[[1]])
str(levels(ff))
a <- matrix( c(NA, "a", "b", "10",
NA, NA, "d", "12",
NA, NA, NA, "14"),
byrow=T, ncol=4 )
print(a, right=TRUE, na.print=" ")
print(a, right=TRUE, na.print="----")
A <- matrix(1:4, 2)
aa <- factor(letters[1:2])
dimnames(A) <- list(aa, NULL)
A
dimnames(A)
set.seed(123)
x2 <- x1 <- 1:10
x3 <- 0.1*(1:10)^2
y <- x1 + rnorm(10)
(fit <- lm(y ~ x1 + x2 + x3))
summary(fit, cor = TRUE)
(fit <- glm(y ~ x1 + x2 + x3))
summary(fit, cor = TRUE)
women["height"]
women["height", drop = FALSE]
women["height", drop = TRUE]
women[,"height", drop = FALSE]
women[,"height", drop = TRUE]
make.names("")
make.names(".aa")
make.names(".2")
make.names(".2a")
make.names(as.character(NA))
as.data.frame(list(row.names=17))
aa <- data.frame(aa=1:3)
aa[["row.names"]] <- 4:6
aa
A <- matrix(4:9, 3, 2)
colnames(A) <- letters[1:2]
aa[["row.names"]] <- A
aa
a <- NULL
a[["a"]] <- 1
a
a <- NULL
a[["a"]] <- "something"
a
a <- NULL
a[["a"]] <- 1:3
a
y <- rnorm(10)
x <- rep(0, 10)
(fit <- lm(y ~ 0))
summary(fit)
anova(fit)
predict(fit)
predict(fit, data.frame(x=x), se=TRUE)
predict(fit, type="terms", se=TRUE)
variable.names(fit)
model.matrix(fit)
(fit <- lm(y ~ x + 0))
summary(fit)
anova(fit)
predict(fit)
predict(fit, data.frame(x=x), se=TRUE)
predict(fit, type="terms", se=TRUE)
variable.names(fit)
model.matrix(fit)
(fit <- glm(y ~ 0))
summary(fit)
anova(fit)
predict(fit)
predict(fit, data.frame(x=x), se=TRUE)
predict(fit, type="terms", se=TRUE)
(fit <- glm(y ~ x + 0))
summary(fit)
anova(fit)
predict(fit)
predict(fit, data.frame(x=x), se=TRUE)
predict(fit, type="terms", se=TRUE)
dat <- data.frame(y=rnorm(10), x1=1:10, x2=1:10, x3 = 0, wt=c(0,rep(1, 9)),
row.names=letters[1:10])
dat[3, 1] <- dat[4, 2] <- NA
lm.influence(lm(y ~ x1 + x2, data=dat, weights=wt, na.action=na.omit))
lm.influence(lm(y ~ x1 + x2, data=dat, weights=wt, na.action=na.exclude))
lm.influence(lm(y ~ 0, data=dat, weights=wt, na.action=na.omit))
print(width = 99,
lm.influence(lm(y ~ 0, data=dat, weights=wt, na.action=na.exclude))
) ; stopifnot(getOption("width") == 80)
lm.influence(lm(y ~ 0 + x3, data=dat, weights=wt, na.action=na.omit))
lm.influence(lm(y ~ 0 + x3, data=dat, weights=wt, na.action=na.exclude))
lm.influence(lm(y ~ 0, data=dat, na.action=na.exclude))
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=1)
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=2)
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=3)
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=4)
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=5)
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=6)
ARMAacf(ar=c(1.3,-0.6, -0.2, 0.1),lag.max=10)
x <- data.frame(a = 1, b = 2)
try(x[c("a", "c")])
try(x[, c("a", "c")])
try(x[1, c("a", "c")])
meth2gen <- function(cl)
noquote(sub(paste("\\.",cl,"$",sep=""),"", c(.S3methods(class = cl))))
meth2gen("data.frame")
meth2gen("dendrogram")
x <- array(1:5, dim=c(5))
dim(x)
dim(x[, drop=TRUE])
dim(x[2:3])
dim(x[2])
dim(x[2, drop=FALSE])
dimnames(x) <- list(some=letters[1:5])
x[]
x[2:3]
x[2]
x[2, drop=FALSE]
x <- cbind(c(1,NA,2,3), c(NA,2,NA,1))
(d <- dist(x))
print(d, diag = TRUE)
attributes(terms(~ a + b + a:b + offset(c)))[c("offset", "term.labels")]
attributes(terms(y ~ a + b + a:b + offset(c)))[c("offset", "term.labels")]
attributes(terms(~ offset(c) + a + b + a:b))[c("offset", "term.labels")]
attributes(terms(y ~ offset(c) + a + b + a:b))[c("offset", "term.labels")]
m <- model.frame(~x, data.frame(x=NA), na.action=na.pass)
model.matrix(~x, m)
lm.fit <- lm(y ~ x, data.frame(x=1:10, y=1:10))
try(predict(lm.fit, data.frame(x=NA)))
y1 <- array(1:10, dim=10)
y2 <- array(1:30, dim=c(10,3), dimnames=list(NULL, letters[1:3]))
y3 <- array(1:40, dim=c(10,2,2),
dimnames=list(NULL, letters[1:2], NULL))
data.frame(y=y1)
data.frame(y=y2)
data.frame(y=y3)
as.data.frame(y1)
as.data.frame(y2)
as.data.frame(y3)
X <- data.frame(x=1:10)
X$y <- y1
X
sapply(X, dim)
X$y <- y2
X
sapply(X, dim)
X$y <- y3
X
sapply(X, dim)
for(id in c("A", "B")) {
eval(substitute(
{
setHook(packageEvent("stats4", "onLoad"),
function(pkgname, ...) cat("onLoad", sQuote(pkgname), id, "\n"));
setHook(packageEvent("stats4", "attach"),
function(pkgname, ...) cat("attach", sQuote(pkgname), id, "\n"));
setHook(packageEvent("stats4", "detach"),
function(pkgname, ...) cat("detach", sQuote(pkgname), id, "\n"));
setHook(packageEvent("stats4", "onUnload"),
function(pkgname, ...) cat("onUnload", sQuote(pkgname), id, "\n"))
},
list(id=id)))
}
loadNamespace("stats4")
library("stats4")
detach("package:stats4")
unloadNamespace("stats4")
rep(integer(0), length.out=0)
rep(integer(0), length.out=10)
typeof(.Last.value)
rep(logical(0), length.out=0)
rep(logical(0), length.out=10)
typeof(.Last.value)
rep(numeric(0), length.out=0)
rep(numeric(0), length.out=10)
typeof(.Last.value)
rep(character(0), length.out=0)
rep(character(0), length.out=10)
typeof(.Last.value)
rep(complex(0), length.out=0)
rep(complex(0), length.out=10)
typeof(.Last.value)
rep(list(), length.out=0)
rep(list(), length.out=10)
array(numeric(0), c(2, 2))
array(list(), c(2,2))
matrix(character(0), 1, 2)
matrix(integer(0), 1, 2)
matrix(logical(0), 1, 2)
matrix(numeric(0), 1, 2)
matrix(complex(0), 1, 2)
matrix(list(), 1, 2)
rep(1:2, each=3, length=12)
set.seed(1)
test.df <- data.frame (y=rnorm(8), a=gl(2,1,8), b=gl(2,3,8),c=gl(2,4,8))
aov(y ~ a + b + Error(c), data=test.df)
aov(y ~ a + b - 1 + Error(c), data=test.df)
binom.test(c(800,10))
rd <- c(16.53, 12.12, 10.04, 15.32, 12.33, 10.1, 17.09, 11.69, 11.81, 14.75,
10.72, 8.79, 13.14, 9.79, 8.36, 15.62, 9.64, 8.72, 15.32,
11.35, 8.52, 13.27, 9.74, 8.78, 13.16, 10.16, 8.4, 13.08, 9.66,
8.16, 12.17, 9.13, 7.43, 13.28, 9.16, 7.92, 118.77, 78.83, 62.2,
107.29, 73.79, 58.59, 118.9, 66.35, 53.12, 372.62, 245.39, 223.72,
326.03, 232.67, 209.44, 297.55, 239.71, 223.8)
sample.df <- data.frame(dep.variable=rd,
subject=factor(rep(paste("subj",1:6, sep=""),each=9)),
f1=factor(rep(rep(c("f1","f2","f3"),each=6),3)),
f2=factor(rep(c("g1","g2","g3"),each=18))
)
sample.aov <- aov(dep.variable ~ f1 * f2 + Error(subject/(f1+f2)), data=sample.df)
sample.aov
summary(sample.aov)
sample.aov <- aov(dep.variable ~ f1 * f2 + Error(subject/(f2+f1)), data=sample.df)
sample.aov
summary(sample.aov)
stem(rep(1, 100))
stem(rep(0.1, 10))
stem(c(rep(1, 10), 1+1.e-8))
stem(c(rep(1, 10), 1+1.e-9))
stem(c(rep(1, 10), 1+1.e-10), atom=0)
set.seed(1)
x1 <- rnorm(3)
y1 <- rnorm(4)
x1 * y1
x1 * as.matrix(y1)
x1 * matrix(y1,2,2)
z1 <- x1 > 0
z2 <- y1 > 0
z1 & z2
z1 & as.matrix(z2)
x1 < y1
x1 < as.matrix(y1)
library(stats4)
N <- c(rep(3:6, 3), 7,7, rep(8,6), 9,9, 10,12)
summary(mle(function(Lam = 1) -sum(dpois(N, Lam))))
df <- data.frame(x=1:4, y=sqrt( 1:4), z=c(2:4,1))
fit1 <- glm(y ~ offset(x) + z, data=df)
update(fit1, ". ~.")$call
terms(y ~ offset(x) + offset(log(x)) + z, data=df)
terms(y ~ offset(x) + z - z, data=df, simplify = TRUE)
3:4 * 1e-100
8:11* 1e-100
1:2 * 1e-99
1:2 * 1e+99
8:11* 1e+99
3:4 * 1e+100
x <- 1:3
try(x[-c(1, NA)])
boxplot(count ~ spray, data = InsectSprays, border=2:7)
summary(as.Date(paste("2002-12", 26:31, sep="-")))
as.matrix(data.frame(d = as.POSIXct("2004-07-20")))
x <- quote(b)
dump("x", "")
x <- 1:26
names(x) <- letters
x[c("a", "aa", "aa")] <- 100:102
x
x <- 1:26
names(x) <- rep("", 26)
x[c("a", "aa", "aa")] <- 100:102
x
x <- "A test string"
(y <- charToRaw(x))
(xx <- c(y, as.raw(0), charToRaw("more")))
!y
y & as.raw(15)
y | as.raw(128)
zz <- file("testbin", "wb")
writeBin(xx, zz)
close(zz)
zz <- file("testbin", "rb")
(yy <- readBin(zz, "raw", 100))
seek(zz, 0, "start")
readBin(zz, "integer", n=100, size = 1)
seek(zz, 0, "start")
readBin(zz, "character", 100)
seek(zz, 0, "start")
readChar(zz, length(xx))
seek(zz)
close(zz)
unlink("testbin")
cat(xx, file="testascii")
scan("testascii", what=raw(0))
unlink("testascii")
set.seed(1)
y <- rnorm(10)
x <- cbind(1:10, sample(1:10))
xt <- cbind(1:2, 3:4)
(lm1 <- lm(y ~ x))
predict(lm1, newdata = data.frame(x= xt))
data(trees)
a <- trees
eval(quote({Girth[1]<-NA;Girth}),a)
a[1, ]
trees[1, ]
x <- data.frame("test string with \"" = c("a \" and a '"), check.names=FALSE)
write.table(x)
write.table(x, qmethod = "double")
Mat <- matrix(c(1:3, letters[1:3], 1:3, LETTERS[1:3],
c("2004-01-01", "2004-02-01", "2004-03-01"),
c("2004-01-01 12:00", "2004-02-01 12:00", "2004-03-01 12:00")),
3, 6)
foo <- tempfile(tmpdir = getwd())
write.table(Mat, foo, col.names = FALSE, row.names = FALSE)
read.table(foo, colClasses = c(NA, NA, "NULL", "character", "Date", "POSIXct"),
stringsAsFactors=TRUE)
unlist(sapply(.Last.value, class))
read.table(foo, colClasses = c("factor",NA,"NULL","factor","Date","POSIXct"),
stringsAsFactors=TRUE)
unlist(sapply(.Last.value, class))
read.table(foo, colClasses = c(V4="character"), stringsAsFactors=TRUE)
unlist(sapply(.Last.value, class))
unlink(foo)
write.table(data.frame(x = 0.5+1:4, y = 1:4 + 1.5i), file = "")
write.table(data.frame(x = 0.5+1:4, y = 1:4 + 1.5i), file = "", dec=",")
(x <- seq(0,6, length=25))
mx <- sapply(c("fmm", "nat", "per"),
function(m) splinefun(1:5, c(1,2,4,3,1), method = m)(x))
cbind(x,mx)
cat(file="test.txt", sep = "\n", "
"1 234567
read.fwf("test.txt", width=c(2,2,3), skip=1, n=4)
read.fwf("test.txt", width=c(2,2,3), skip=1)
read.fwf("test.txt", width=c(2,2,3), skip=0)
unlink("test.txt")
split(as.list(1:3), c(1,1,2))
(y <- charToRaw("A test string"))
(z <- split(y, rep(1:5, times=c(1,1,4,1,6))))
sapply(z, rawToChar)
foo <- function(x, ...) UseMethod("foo")
foo.numeric <- function(x) cat("numeric arg\n")
foo(1:10)
foo(pi)
foo(matrix(1:10, 2, 5))
foo.integer <- function(x) cat("integer arg\n")
foo.double <- function(x) cat("double arg\n")
foo(1:10)
foo(pi)
foo(matrix(1:10, 2, 5))
x <- "ab\bc\ndef"
str(x)
str(x, vec.len=0)
str(factor(x))
x <- c("a", NA, "b")
factor(x)
factor(x, exclude="")
str(x)
str(factor(x))
str(factor(x, exclude=""))
x <- c("a", NA, "b", 'a " test')
factor(x)
factor(x, exclude="")
print(factor(x), quote=TRUE)
print(factor(x, exclude=""), quote=TRUE)
x <- matrix(, 3, 0)
write.table(x)
write.table(x, row.names=FALSE)
x <- list(a=1, b=1:2, c=3:4, d=5)
dim(x) <- c(2,2)
x
write.table(x)
x1 <- data.frame(a=1:2, b=I(matrix(LETTERS[1:4], 2, 2)), c = c("(i)", "(ii)"))
x1
write.table(x1)
write.table(x1, quote=c(2,3,4))
x2 <- data.frame(a=1:2, b=I(list(a=1, b=2)))
x2
write.table(x2)
x3 <- seq(as.Date("2005-01-01"), len=6, by="day")
x4 <- data.frame(x=1:6, y=x3)
dim(x3) <- c(2,3)
x3
write.table(x3)
x4
write.table(x4)
grep("(.*s){2}", "Arkansas", v = TRUE)
grep("(.*s){3}", "Arkansas", v = TRUE)
grep("(.*s){3}", state.name, v = TRUE)
xx<- data.frame(a=1:4, b=letters[1:4])
xx[2:3, "c"] <- 2:3
y <- rnorm(1:20)
x <- 1:20; x[10] <- NA
x2 <- runif(20); x2[20] <- NA
fit <- lm(y ~ x)
drop1(fit)
res <- try(stats:::drop1.default(fit))
stopifnot(inherits(res, "try-error"))
add1(fit, ~ . +x2)
res <- try(stats:::add1.default(fit, ~ . +x2))
stopifnot(inherits(res, "try-error"))
tf <- tempfile(tmpdir = getwd())
x <- c("6 'TV2 Shortland Street'",
"2 'I don\\\'t watch TV at 7'",
"1 'I\\\'m not bothered, whatever that looks good'",
"2 'I channel surf'")
writeLines(x, tf)
read.table(tf)
x <- c("6 'TV2 Shortland Street'",
"2 'I don''t watch TV at 7'",
"1 'I''m not bothered, whatever that looks good'",
"2 'I channel surf'")
writeLines(x, tf)
read.table(tf, sep=" ")
unlink(tf)
set.seed(123)
cmat <- cbind(rnorm(3, 10), sqrt(rchisq(3, 12)))
cmat <- cbind(cmat, cmat[,1]/cmat[,2])
cmat <- cbind(cmat, 2*pnorm(-cmat[,3]))
colnames(cmat) <- c("Estimate", "Std.Err", "Z value", "Pr(>z)")
printCoefmat(cmat, signif.stars = TRUE)
printCoefmat(cmat, signif.stars = TRUE, signif.legend = FALSE)
printCoefmat(cmat, signif.stars = FALSE)
printCoefmat(cmat, signif.stars = TRUE, signif.legend = TRUE)
x <- matrix(1:6, ncol=2)
x[rbind(c(1,1), c(2,2))]
x[rbind(c(1,1), c(2,2), c(0,1))]
x[rbind(c(1,1), c(2,2), c(0,0))]
x[rbind(c(1,1), c(2,2), c(0,2))]
x[rbind(c(1,1), c(2,2), c(0,3))]
x[rbind(c(1,1), c(2,2), c(1,0))]
x[rbind(c(1,1), c(2,2), c(2,0))]
x[rbind(c(1,1), c(2,2), c(3,0))]
x[rbind(c(1,0), c(0,2), c(3,0))]
x[rbind(c(1,0), c(0,0), c(3,0))]
x[rbind(c(1,1), c(2,2), c(1,2))]
x[rbind(c(1,1), c(2,NA), c(1,2))]
x[rbind(c(1,0), c(2,NA), c(1,2))]
try(x[rbind(c(1,1), c(2,2), c(-1,2))])
try(x[rbind(c(1,1), c(2,2), c(-2,2))])
try(x[rbind(c(1,1), c(2,2), c(-3,2))])
try(x[rbind(c(1,1), c(2,2), c(-4,2))])
try(x[rbind(c(1,1), c(2,2), c(-1,-1))])
try(x[rbind(c(1,1,1), c(2,2,2))])
x <- matrix(1:6, ncol=3)
try(x[rbind(c(1,1), c(2,2), c(-3,3))])
try(x[rbind(c(1,1), c(2,2), c(-4,3))])
s <- sapply(0:7, function(i) rawShift(charToRaw("my text"),i))
s
dim(s) <- c(7,4,2)
s
dd <- data.frame(a = gl(3,4), b = gl(4,1,12))
model.matrix(~ .^2, data = dd)
set.seed(2)
y <- rnorm(10)
z <- 1:10
lm0 <- lm(y ~ 1)
lm1 <- lm(y ~ 1, offset = 1:10)
lm2 <- lm(y ~ z, offset = 1:10)
add1(lm0, scope = ~ z)
anova(lm1, lm2)
add1(lm1, scope = ~ z)
drop1(lm2)
as.raw(1234)
as.raw(list(a=1234))
df1 <- data.frame(a = c(NA, 0, 3, 4)); m1 <- as.matrix(df1)
df2 <- data.frame(a = c(NA, 0, 0, 4)); m2 <- as.matrix(df2)
df1[df1 == 0] <- 2; df1
m1[m1 == 0] <- 2; m1
df2[df2 == 0] <- 2; df2
m2[m2 == 0] <- 2; m2
df1[df1 == 2]
df3 <- data.frame(a=1:2, b=2:3)
df3[df3 == 2]
tryCatch(df2[df2 == 2] <- 1:2,
error = function(e) paste("Error:", conditionMessage(e)))
tryCatch(m2[m2 == 2] <- 1:2,
error = function(e) paste("Error:", conditionMessage(e)))
m1 <- c(0,1,2,0)
dim(m1) <- 4
dimnames(m1) <- list(1:4)
m1[m1 == 0]
m1[which(m1 == 0)]
m1[which(m1 == 0, arr.ind = TRUE)]
m2 <- as.matrix(data.frame(a=c(0,1,2,0), b=0:3))
m2[m2 == 0]
m2[which(m2 == 0)]
m2[which(m2 == 0, arr.ind = TRUE)]
m21 <- m2[, 1, drop = FALSE]
m21[m21 == 0]
m21[which(m21 == 0)]
m21[which(m21 == 0, arr.ind = TRUE)]
x <- NULL
x$foo <- 2
x
x <- NULL
x[[2]] <- pi
x
x <- NULL
x[[1]] <- 1:3
x
kernel(1)
DF <- data.frame(A=1:2, B=3:4)
try(DF[2, 1:3] <- NULL)
ob <- 0:9 * 2000
print(signif(ob, 3), digits=17)
signif(1.2347e-305, 4)
signif(1.2347e-306, 4)
signif(1.2347e-307, 4)
A <- list(1, 2)
names(A) <- c("NA", NA)
A
x <- 1:4
names(x) <- c(NA, "NA", "a", "")
x[names(x)]
lx <- as.list(x)
lx[[as.character(NA)]]
lx[as.character(NA)]
a.frame <- data.frame( x=letters[1:5] )
a.frame[ 2:5, "y" ] <- letters[2:5]
a.frame
a.frame[ ,"y" ] <- matrix(1:10, 5, 2)
a.frame
a.frame[3:5 ,"y" ] <- matrix(1:6, 3, 2)
a.frame
a.frame <- data.frame( x=letters[1:5] )
a.frame[3:5 ,"y" ] <- matrix(1:6, 3, 2)
a.frame
pairs(iris[1:4], oma=rep(3,4))
dend <- as.dendrogram(hclust(dist(USArrests), "ave"))
dend2 <- cut(dend, h=70)
str(dend2$upper)
xx <- pi * 10^(-5:4)
cbind(formatC(xx, wid = 9))
cbind(formatC(xx, wid = 9, flag = "-"))
cbind(formatC(xx, wid = 9, flag = "0"))
success <- c(13,12,11,14,14,11,13,11,12)
failure <- c(0,0,0,0,0,0,0,2,2)
predictor <- c(0, 5^(0:7))
try(glm(cbind(success,failure) ~ 0+predictor, family = binomial(link="log")))
temp <- diag(1, 5)[, 1:4]
rownames(temp) <- as.character(1:5)
colnames(temp) <- as.character(1:4)
try(solve(temp))
try(solve(temp+0i))
try(solve(temp, diag(3)))
update.formula (Reaction ~ Days + (Days | Subject), . ~ . + I(Days^2))
pgamma(seq(0.75, 1.25, by=0.05)*1e100, shape = 1e100, log=TRUE)
pgamma(seq(0.75, 1.25, by=0.05)*1e100, shape = 1e100, log=TRUE, lower=FALSE)
pgamma(c(1-1e-10, 1+1e-10)*1e100, shape = 1e100)
pgamma(0.9*1e25, 1e25, log=TRUE)
c(10485849600,10477641600,10561104000,10562745600)+ISOdate(1582,10,14)
op <- options(deparse.max.lines = 3)
f <- function(...) browser()
do.call(f, mtcars)
c
op <- c(op, options(error = expression(NULL)))
f <- function(...) stop()
do.call(f, mtcars)
traceback()
g <- function(fun) fun(1)
debug(g)
g(function(x) x+1)
options(op)
as.table(matrix(1:60, ncol=2))
y <- rnorm(10)
x <- 1:10
w <- c(rep(1,9), 0)
summary(glm(y ~ x, weights = w))
summary(glm(y ~ x, subset = w > 0))
yaa <- function(...) substitute(list(...))
yaa(foo(...))
substitute(list(..., x), list(x=1))
ff <- function(x) (x-pi)^3
uniroot(ff, c(-10,10), maxiter=10)
try(min(list()))
try(max(list()))
try(sum(list()))
try(prod(list()))
try(min(raw()))
try(max(raw()))
try(sum(raw()))
try(prod(raw()))
r <- hist(rnorm(100), plot = FALSE, breaks = 12,
xlab = "N(0,1)", col = "blue")
d1 <- data.frame(x=1:10, y=letters[1:10], z=1:10)
d2 <- data.frame(y=LETTERS[1:5], z=5:1, x=7:11)
rbind(d1, d2)
d1 <- data.frame(x=1:2, y=5:6, x=8:9, check.names=FALSE)
d2 <- data.frame(x=3:4, x=-(1:2), y=8:9, check.names=FALSE)
rbind(d1, d2)
x <- rep(2:1, c(2, 2)) + 1i*c(4, 1, 2, 3)
(o <- sort.list(x))
x[o]
sort(x)
m <- matrix(1:9, nrow=3, dimnames=list(c("A","B","C"), c("I","II","III")))
write.table(m)
write.table(m, col.names=FALSE)
write.table(m, row.names=FALSE)
write.table(m, quote=FALSE)
write.table(m, col.names=FALSE, quote=FALSE)
write.table(m, row.names=FALSE, quote=FALSE)
d <- as.data.frame(m)
write.table(d)
write.table(d, col.names=FALSE)
write.table(d, row.names=FALSE)
write.table(d, quote=FALSE)
write.table(d, col.names=FALSE, quote=FALSE)
write.table(d, row.names=FALSE, quote=FALSE)
write.table(m, quote=numeric(0))
try(remove("ls", envir=baseenv()))
try(remove("ls", envir=asNamespace("base")))
(x <- factor(LETTERS[1:5])[2:4])
x[2]
x[[2]]
stopifnot(identical(x[2], x[[2]]))
as.list(x)
(xx <- unlist(as.list(x)))
stopifnot(identical(x, xx))
as.vector(x, "list")
(sx <- sapply(x, function(.).))
stopifnot(identical(x, sx))
as.character(as.factor(c("AB", "CD", NA)))
as.character(as.factor(c("NA", "CD", NA)))
as.vector(as.factor(c("NA", "CD", NA)))
data.frame()[FALSE]
names(data.frame())
d.AD <- data.frame(treatment = gl(3,3), outcome = gl(3,1,9),
counts = c(18,17,15,20,10,20,25,13,12))
fit <- glm(counts ~ outcome + treatment, family = poisson,
data = d.AD, weights = c(0, rep(1,8)))
print(residuals(fit, type="working"),
width = 37)
fit2 <- glm(counts ~ outcome + treatment, family = poisson,
data = d.AD, weights = c(0, rep(1,8)), y = FALSE)
for(z in c("response", "working", "deviance", "pearson"))
stopifnot(all.equal(residuals(fit, type=z), residuals(fit2, type=z),
scale = 1, tolerance = 1e-10))
A <- array(0, c(3, 0, 4))
dimnames(A) <- list(D1 = letters[1:3], D2 = NULL, D3 = LETTERS[1:4])
f <- function(x) 5
apply(A, 1:2, f)
apply(A, 1, f)
apply(A, 2, f)
structure(factor(1:4), names = letters[1:4])
A <- factor(7:12)
dim(A) <- c(2, 3)
A
str(A)
A[, 1:2]
A[, 1:2, drop=TRUE]
A[1,1] <- "9"
A
nc <- c(0, 0.0001, 1)
dt(1.8, 10, nc)
pt(1.8, 10, nc)
qt(0.95, 10, nc)
dt(1.8, 10, -nc[-1])
pt(1.8, 10, -nc[-1])
qt(0.95, 10, -nc[-1])
A <- data.frame(a = 1:4)
row.names(A) <- c("2002-11-15", "2002-12-15", "2003-01-15", "2003-02-15")
B <- data.frame(b = 1:4)
row.names(B) <- c("2002-09-15", "2002-10-15", "2002-11-15", "2002-12-15")
merge(A, B, by=0, all=TRUE)
L <- list(a = list(txt = "original value"))
f <- function(LL) {
for (ll in LL) ll$txt <- "changed in f"
LL
}
f(L)
L
n <- 50
x <- runif(n=n)
y1 <- 2 * x + rnorm(n=n)
y2 <- 5 * x + rnorm(n=n)
y2[sample(1:n, size=5)] <- NA
y <- cbind(y1, y2)
fit <- lm(y ~ 1, na.action="na.exclude")
summary(fit)
RNGkind("default","default")
format(matrix(1:16, 4), big.mark = ",")
1e100 + 1e44i
1e100 + pi*1i*10^(c(-100,0,1,40,100))
x <- c(0,7,8,14,15,120,242)
y <- c(122,128,130,158,110,110,92)
lowess(x, y, iter=0)
lowess(x, y)
a <- list(b=5)
a[[(t<-'b')]]
x <- matrix(5:-6, 3)
x[2, invisible(3)]
x <-list(a = NA, b = as.integer(NA), c=0+NA, d=0i+NA,
e = 1, f = 1:1, g = 1:3, h = c(NA, 1:3),
i = as.character(NA), j = c("foo", NA, "bar")
)
dput(x, control=NULL)
dput(x, control="keepInteger")
dput(x, control="keepNA")
dput(x)
dput(x, control="all")
dput(x, control=c("all", "S_compatible"))
tmp <- tempfile(tmpdir = getwd())
dput(x, tmp, control="all")
stopifnot(identical(dget(tmp), x))
dput(x, tmp, control=c("all", "S_compatible"))
stopifnot(identical(dget(tmp), x))
unlink(tmp)
d <- data.frame(y= runif(10), x=runif(10))
try(nls(y ~ 1/(1+x), data = d, start=list(x=0.5,y=0.5), trace=TRUE))
cut(as.Date(c("2000-01-17","2001-01-13","2001-01-20")), breaks="years")
cut(as.POSIXct(c("2000-01-17","2001-01-13","2001-01-20")), breaks="years")
A <- data.frame(a=character(0))
try(row.names(A) <- 1:10)
A <- list(a=1:3)
class(A) <- "data.frame"
row.names(A) <- letters[24:26]
A
w <- women[1, ]
w[]
w[,drop = TRUE]
w[1,]
w[,]
w[1, , drop = FALSE]
w[, , drop = FALSE]
w[1, , drop = TRUE]
w[, , drop = TRUE]
(x <- data.frame(row.names=1:4))
nrow(x)
row.names(x)
attr(x, "row.names")
d0 <- d1 <- data.frame(1:4, row.names=1:4)
row.names(d0) <- NULL
dput(d0)
dput(d1)
identical(d0, d1)
all.equal(d0, d1)
identical(d0, d1, attrib.as.set = FALSE)
row.names(d1) <- as.character(1:4)
dput(d1)
identical(d0, d1)
all.equal(d0, d1)
all.equal(data.frame(x=1:5, row.names=letters[1:5]),
data.frame(x=1:5,row.names=LETTERS[1:5]),
check.attributes=FALSE)
all.equal(c(T, F, F), c(T, T, F))
all.equal(c(T, T, F), c(T, F, F))
all.equal(as.raw(1:3), as.raw(1:3))
all.equal(as.raw(1:3), as.raw(3:1))
f <- function(x, xm = max(1L, x)) {xx <- 0L; yy <- NA_real_}
attr(f, "srcref") <- srcref(srcfilecopy("",
"function(x, xm = max(1L, x)) {xx <- 0L; yy <- NA_real_}"),
c(1L, 1L, 1L, 56L))
f
dput(f)
dput(f, control="all")
cat(deparse(f), sep="\n")
dump("f", file="")
attr(f, "srcref") <- NULL
f
dput(f, control="all")
dump("f", file="")
expression(bin <- bin + 1L)
x <- "abcde"
substr(x, 1, 3)
substr(x, NA, 1)
substr(x, 1, NA)
substr(x, NA, 3) <- "abc"; x
substr(x, 1, NA) <- "AA"; x
substr(x, 1, 2) <- NA_character_; x
pmin(NULL, integer(0))
pmax(integer(0), NULL)
pmin(NULL, 1:3)
pmax(pi, NULL, 2:4)
x <- c(1, NA, NA, 4, 5)
y <- c(2, NA, 4, NA, 3)
pmin(x, y)
stopifnot(identical(pmin(x, y), pmin(y, x)))
pmin(x, y, na.rm=TRUE)
stopifnot(identical(pmin(x, y, na.rm=TRUE), pmin(y, x, na.rm=TRUE)))
pmax(x, y)
stopifnot(identical(pmax(x, y), pmax(y, x)))
pmax(x, y, na.rm=TRUE)
stopifnot(identical(pmax(x, y, na.rm=TRUE), pmax(y, x, na.rm=TRUE)))
x <- as.integer(x); y <- as.integer(y)
pmin(x, y)
stopifnot(identical(pmin(x, y), pmin(y, x)))
pmin(x, y, na.rm=TRUE)
stopifnot(identical(pmin(x, y, na.rm=TRUE), pmin(y, x, na.rm=TRUE)))
pmax(x, y)
stopifnot(identical(pmax(x, y), pmax(y, x)))
pmax(x, y, na.rm=TRUE)
stopifnot(identical(pmax(x, y, na.rm=TRUE), pmax(y, x, na.rm=TRUE)))
x <- as.character(x); y <- as.character(y)
pmin(x, y)
stopifnot(identical(pmin(x, y), pmin(y, x)))
pmin(x, y, na.rm=TRUE)
stopifnot(identical(pmin(x, y, na.rm=TRUE), pmin(y, x, na.rm=TRUE)))
pmax(x, y)
stopifnot(identical(pmax(x, y), pmax(y, x)))
pmax(x, y, na.rm=TRUE)
stopifnot(identical(pmax(x, y, na.rm=TRUE), pmax(y, x, na.rm=TRUE)))
x <- .leap.seconds[1:23]; y <- rev(x)
x[2] <- y[2] <- x[3] <- y[4] <- NA
format(pmin(x, y), tz="GMT")
class(pmin(x, y))
stopifnot(identical(pmin(x, y), pmin(y, x)))
format(pmin(x, y, na.rm=TRUE), tz="GMT")
stopifnot(identical(pmin(x, y, na.rm=TRUE), pmin(y, x, na.rm=TRUE)))
format(pmax(x, y), tz="GMT")
stopifnot(identical(pmax(x, y), pmax(y, x)))
format(pmax(x, y, na.rm=TRUE), tz="GMT")
stopifnot(identical(pmax(x, y, na.rm=TRUE), pmax(y, x, na.rm=TRUE)))
x <- as.POSIXlt(x, tz="GMT"); y <- as.POSIXlt(y, tz="GMT")
format(pmin(x, y), tz="GMT")
class(pmin(x, y))
stopifnot(identical(pmin(x, y), pmin(y, x)))
format(pmin(x, y, na.rm=TRUE), tz="GMT")
stopifnot(identical(pmin(x, y, na.rm=TRUE), pmin(y, x, na.rm=TRUE)))
format(pmax(x, y), tz="GMT")
stopifnot(identical(pmax(x, y), pmax(y, x)))
format(pmax(x, y, na.rm=TRUE), tz="GMT")
stopifnot(identical(pmax(x, y, na.rm=TRUE), pmax(y, x, na.rm=TRUE)))
x <- as.array(1:3)
names(x) <- letters[x]
names(x)
dimnames(x)
attributes(x)
names(x) <- NULL
attr(x, "names") <- LETTERS[x]
names(x)
dimnames(x)
attributes(x)
x <- 1:3
attr(x, "NA") <- 4
attributes(x)
attr(x, "NA")
attr(x, NA_character_)
try(attr(x, NA_character_) <- 5)
A <- matrix(c(0,0,0, 1,1,1), nrow = 3,
dimnames = list(letters[1:3], c("zero","one")))
y <- matrix(c(6,7,8), nrow = 3, dimnames = list(LETTERS[1:3], "y"))
qr.coef(qr(A), y)
qr.fitted(qr(A), y)
qr.coef(qr(matrix(0:1, 1, dimnames=list(NULL, c("zero","one")))), 5)
x <- as.raw(65:74)
readChar(x, nchar=c(3,3,0,3,3,3))
f <- tempfile(tmpdir = getwd())
writeChar("ABCDEFGHIJ", con=f, eos=NULL)
readChar(f, nchar=c(3,3,0,3,3,3))
unlink(f)
set.seed(1)
X <- cbind(NA, 1:3, rnorm(3))
try(cor(X, use = "complete"))
try(cor(X, use = "complete", method="spearman"))
try(cor(X, use = "complete", method="kendall"))
cor(X, use = "pair")
cor(X, use = "pair", method="spearman")
cor(X, use = "pair", method="kendall")
X[1,1] <- 1
cor(X, use = "complete")
cor(X, use = "complete", method="spearman")
cor(X, use = "complete", method="kendall")
cor(X, use = "pair")
cor(X, use = "pair", method="spearman")
cor(X, use = "pair", method="kendall")
junk <- data.frame(x = rep(1, 10L),
u = factor(sample(c("Y", "N"), 10, replace=TRUE)),
ans = rnorm(10))
fit <- lm(ans ~ x + u, data = junk)
confint(fit)
confint.default(fit)
x <- data.frame(a=1:3, b=2:4)
x[,3] <- x
x
x <- factor(c("aa", letters[-1]))
dim(x) <- c(13,2)
format(x, justify="right")
abc <- data.frame(a=1:5, b=2:6, c=3:7)
within(abc, b<-NULL)
within(abc,{d<-a+7;b<-NULL})
within(abc,{a<-a+7;b<-NULL})
z <- data.frame(a=integer(0), b=numeric(0))
try(aggregate(z, by=z[1], FUN=sum))
aggregate(data.frame(a=1:10)[F], list(rep(1:2, each=5)), sum)
z <- data.frame(a=1, a=2, b=3, check.names=FALSE)
z[]
z[1, ]
TS <- ts(co2[1:192], freq=24)
tmp2 <- window(TS, start(TS), end(TS))
Call <- call("foo", 1)
Call[["bar"]] <- 2
Call
options(keep.source = TRUE)
foo <- function(given = NULL) {
callObj <- quote(callFunc())
if(!is.null(given)) callObj$given <- given
if (is.null(given)) callObj$default <- TRUE
callObj
}
foo()
foo(given = TRUE)
foo("blah blah")
foo(given = TRUE)
foo()
forms <- c("%
nums <- list(-3.145, -31, 0xabc, -123L, 123456)
rbind(mapply(sprintf, forms, nums),
mapply(sprintf, sub("
sink(con <- textConnection("of", "w")) ; c ; sink(NULL); close(con)
of2 <- capture.output(print(c))
stopifnot(identical(of2, of),
identical(of2, "function (...) .Primitive(\"c\")"))
foo
print(foo, useSource = FALSE)
attr(foo, "srcref") <- NULL
foo
(f <- structure(function(){}, note = "just a note",
yada = function() "not the same"))
print(f, useSource = TRUE)
print(f, useSource = FALSE)
print.function <- function(x, ...) {
cat("my print(<function>): "); str(x, give.attr=FALSE); invisible(x) }
print.function
print(print.function)
rm(print.function)
print(list(f, expression(foo), f, quote(foo), f, base::list, f),
useSource = FALSE)
printCoefmat(cbind(0,1))
cor.test(c(1, 2, 3, 4, 5), c(8, 6, 7, 5, 3), method = "kendall",
exact = TRUE)
cor.test(c(1, 2, 3, 4, 5), c(8, 6, 7, 5, 3), method = "kendall",
exact = FALSE)
cor.test(c(1, 2, 3, 4, 5), c(8, 6, 7, 5, 3), method = "kendall",
exact = FALSE, continuity = TRUE)
cor.test(c(1, 2, 3, 4, 5), c(8, 6, 7, 5, 3), method = "spearman",
exact = TRUE)
cor.test(c(1, 2, 3, 4, 5), c(8, 6, 7, 5, 3), method = "spearman",
exact = FALSE)
cor.test(c(1, 2, 3, 4, 5), c(8, 6, 7, 5, 3), method = "spearman",
exact = FALSE, continuity = TRUE)
foo <- matrix(1:12, nrow = 3)
bar <- as.data.frame(foo)
val <- integer(0)
try(bar$NewCol <- val)
try(bar[["NewCol"]] <- val)
bar["NewCol"] <- val
bar[, "NewCol2"] <- val
bar[FALSE, "NewCol3"] <- val
bar
m22 <- matrix(list(NA_complex_, 3, "A string", NA_complex_), 2,2)
print(m22)
print(m22, na.print="<missing value>")
update(`a: b` ~ x, ~ . + y)
E <- new.env(); E$cl <- call("print", "Boo !")
ls.str(E)
try(complete.cases())
try(complete.cases(list(), list()))
tst <- function(y) { stopifnot(is.numeric(y)); y+ 1 }
try(tst())
try(c(1,,2))
x <- as.Date(c("2009-03-21","2009-03-31"))
cut(x, breaks= "quarter")
cut(as.POSIXlt(x), breaks= "quarter")
switch("a", a=, b=, c=, 4)
switch("a", a=, b=, c=, )
.Last.value
switch("a", a=, b=, c=, invisible(4))
.Last.value
x <- rep(6:10, 1:5)
aggregate(as.ts(x), FUN = mean, ndeltat = 5)
x <- rep(6:10, 1:5)
aggregate(as.ts(x), FUN = mean, nfrequency = 0.2)
a <- c(0.1, 0.3, 0.4, 0.5, 0.3, 0.0001)
format.pval(a, eps=0.01)
format.pval(a, eps=0.01, nsmall =2)
as.Date(0.5, origin="1969-12-31")
dfr <- data.frame(x=1:6, CC=11:16, f = gl(3,2)); colnames(dfr)[2] <- ""
dfr
set.seed(9); m <- matrix(local({x <- rnorm(40)
sign(x)*round(exp(2*x))/10}), 8,5)
noquote(format(m, zero.print= "."))
min(c(NaN, NA))
min(c(NA, NaN))
min(NaN, NA_real_)
min(NA_real_, NaN)
max(c(NaN, NA))
max(c(NA, NaN))
max(NaN, NA_real_)
max(NA_real_, NaN)
Nitrous <- array(c(32,210,8,26,18,21,3,3,7,75,0,10), dim = c(2,2,3),
dimnames = list(c("Exposed","NotExposed"),
c("FullTerm","Miscarriage"),
c("DentalAsst","OperRoomNurse","OutpatientNurse")))
mantelhaen.test(Nitrous, exact=TRUE, alternative="less")
mantelhaen.test(Nitrous, exact=FALSE, alternative="less")
writeLines(' " A "; "B" ;"C";" D ";"E "; F ;G ', "foo")
cat(readLines("foo"), sep = "\n")
scan('foo', list(""), sep=";")[[1]]
scan('foo', "", sep=";")
scan('foo', list(""), sep=";", strip.white = TRUE)[[1]]
scan('foo', "", sep=";", strip.white = TRUE)
unlink('foo')
writeLines(' " A "\n "B" \n"C"\n" D "\n"E "\n F \nG ', "foo2")
scan('foo2', "")
scan('foo2', "", strip.white=TRUE)
unlink('foo2')
set.seed(1)
x <- runif(10)
y <- runif(10)
x[3] <- NA; y[5] <- NA
xy <- cbind(x, y)
cor(x, y, method = "spearman", use = "complete.obs")
cor(x, y, method = "spearman", use = "pairwise.complete.obs")
cor(na.omit(xy), method = "spearman", use = "complete.obs")
cor(xy, method = "spearman", use = "complete.obs")
cor(xy, method = "spearman", use = "pairwise.complete.obs")
x <- 2e9L
rowsum(c(x, x), c("a", "a"))
rowsum(data.frame(z = c(x, x)), c("a", "a"))
d <- data.frame(num = 1:4,
fac = factor(letters[11:14], levels = letters[1:15]),
date = as.Date("2011-04-01") + (0:3),
pv = package_version(c("1.2-3", "4.5", "6.7", "8.9-10")))
for (i in seq_along(d)) print(d[[1, i]])
as.POSIXlt("2011-05-16 24:00:00", tz = "GMT")
as.POSIXlt("2010-01-31 24:00:00", tz = "GMT")
as.POSIXlt("2011-02-28 24:00:00", tz = "GMT")
as.POSIXlt("2008-02-28 24:00:00", tz = "GMT")
as.POSIXlt("2008-02-29 24:00:00", tz = "GMT")
as.POSIXlt("2010-12-31 24:00:00", tz = "GMT")
try(double(FALSE))
x <- 1:3
try(length(x) <- TRUE)
x <- c(1:4, NA, 6:9)
cbind(x, "1"=filter(x, 0.5, method="recursive"),
"2"=filter(x, c(0.5, 0.0), method="recursive"),
"3"=filter(x, c(0.5, 0.0, 0.0), method="recursive"))
x <- as.POSIXlt(c("2010-02-27 22:30:33", "2009-08-09 06:01:03",
"2010-07-23 17:29:59"))
stopifnot(!is.na(trunc(x, units = "days")[1:3]))
aa <- c(1, 2, 3, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 13, 14)
try(smooth.spline(aa, seq_along(aa)))
fit <- smooth.spline(aa, seq_along(aa), tol = 0.1)
d <- data.frame(x = 1:9,
y = 1:9 + 0.1*c(1, 2, -1, 0, 1, 1000, 0, 1, -1),
w = c(1, 0.5, 2, 1, 2, 0, 1, 2, 1))
fit <- lm(y ~ x, data=d, weights=w)
summary(fit)
is.unsorted(data.frame(x=2:1))
is.unsorted(data.frame(x=1:2, y=3:4))
is.unsorted(data.frame(x=3:4, y=1:2))
library("methods")
assertError <- tools::assertError
assertErrorV <- function(expr) assertError(expr, verbose=TRUE)
assertErrorV( getMethod(ls, "bar", fdef=ls) )
assertErrorV( getMethod(show, "bar") )
try(array(1, integer()))
try(array(1, integer(), list(1, 2)))
DF <- data.frame(row.names=1:3)
is.na(DF); str(.Last.value)
is.na(DF[FALSE, ]); str(.Last.value)
df <- data.frame(x = rep(c("a", "a.b"), 3L), y = rep(c("b.c", "c"), 3L),
z = 1:6)
df
split(df, df[, 1:2])
split(df, df[, 1:2], sep = ":")
z <- c(4L, NA, 2L, 3L, NA, 1L)
order(z, na.last = NA)
sort.list(z, na.last = NA)
sort.list(z, na.last = NA, method = "shell")
sort.list(z, na.last = NA, method = "quick")
sort.list(z, na.last = NA, method = "radix")
NB <- 1000
lns <- capture.output(
setNames(c(255, 1000, 30000),
c(paste(rep.int("a", NB+2), collapse=""),
paste(rep.int("b", NB+2), collapse=""),
paste(rep.int("c", NB+2), collapse=""))))
sub("^ +", '', lns[2* 1:3])
form <- reallylongnamey ~ reallylongnamex0 + reallylongnamex1 + reallylongnamex2 + reallylongnamex3
form
op <- options(deparse.cutoff=80)
form
options(deparse.cutoff=50)
form
options(op)
quote( `%^%`(x, `%^%`(y,z)) )
quote( `%^%`(x) )
substitute(f(x), list(f = function(x) x + 1))
substitute(f(x), list(f = quote(function(x) x + 1)))
substitute(f(x), list(f = quote(f+g)))
substitute(f(x), list(f = quote(base::mean)))
substitute(f(x), list(f = quote(a[n])))
substitute(f(x), list(f = quote(g(y))))
d <- data.frame(1:3, "B", 4, stringsAsFactors=TRUE)
names(d) <- c("A", "B\xba","C\xabcd")
str(d)
1:2 + table(1:2)
x <- c('1', 'B', '3')
m <- regexpr('\\d', x)
regmatches(x, m) <- c('A', 'C')
print(x)
saveopt <- options(warnPartialMatchDollar=TRUE)
pl <- pairlist(abc=1, def=2)
pl$ab
if (!is.null(saveopt[["warnPartialMatchDollar"]])) options(saveopt)
try(seq(NaN))
try(seq(to = NaN))
try(seq(NaN, NaN))
try(seq.int(NaN))
try(seq.int(to = NaN))
try(seq.int(NaN, NaN))
x <- array(0:2, dim=3, dimnames=list(d1=LETTERS[1:3]))
x
x[]
x[3:1]
x <- array(0, dimnames=list(d1="A"))
x
x[]
x[drop = FALSE]
load(file.path(Sys.getenv('SRCDIR'), 'arima.rda'))
(f1 <- arima(x, xreg = xreg, order = c(1,1,1), seasonal = c(1,0,1)))
(f2 <- arima(diff(x), xreg = diff(xreg), order = c(1,0,1), seasonal = c(1,0,1),
include.mean = FALSE))
stopifnot(all.equal(coef(f1), coef(f2), tolerance = 1e-3, check.names = FALSE))
x <- c(a=1, b=2)
y <- c(a=1, d=2)
all.equal(x, y, check.names = FALSE)
format(9992, digits = 3)
format(9996, digits = 3)
format(0.0002, digits = 1, nsmall = 2, scientific = FALSE)
assertErrorV(
format(pi*10, digits = 0))
format(pi*10, digits = 1)
format(pi*10, digits = 1, nsmall = 1)
xx <- c(-86870268, 107833358, 302536985, 481015309, 675718935, 854197259,
1016450281, 1178703303, 1324731023, 1454533441)
xx
1000* ((10^(1/4)) ^ c(0:4))
7/0.07
M <- matrix(11:14, ncol=2, dimnames=list(paste0("Row", 1:2), paste0("Col",
1:2)))
L <- list(elem1=1, elem2=2)
rbind(M, L)
rbind(L, M)
cbind(M, L)
cbind(L, M)
str(min(NA, "bla"))
str(min("bla", NA))
str(min(NA_character_, "bla"))
str(max(NA, "bla"))
str(max("bla", NA))
str(max(NA_character_, "bla"))
oldopts <- options(width=70)
n <- 11
M <- 10000
longer.char.string <- "zjtvorkmoydsepnxkabmeondrjaanutjmfxlgzmrbjp"
X <- data.frame( A = 1:n * M,
B = factor(rep(longer.char.string, n)))
str( X, strict.width = "cut")
options(oldopts)
dpois(2^52,1,1)
dpois(2^52+1,1,1)
f <- file.path(Sys.getenv('SRCDIR'), 'EmbeddedNuls.csv')
read.csv(f)
read.csv(f, skipNul = TRUE, fileEncoding = "UTF-8-BOM")
x <- Sys.time()
all.equal(x,x)
all.equal(x, as.POSIXlt(x), check.tzone = FALSE)
all.equal(x, as.numeric(x))
all.equal(x, as.POSIXlt(x, tz = "EST5EDT"))
all.equal(x, x+1e-4)
isTRUE(all.equal(x, x+0.002))
try(bartlett.test(yield ~ block*N, data = npk))
try(fligner.test (yield ~ block*N, data = npk))
xx <- window(AirPassengers, start = 1960)
cbind(xx, xx)
op <- options(digits = 2)
cbind(xx, xx)
options(op)
difftime(
as.POSIXct(c("1970-01-01 00:00:00", "1970-01-01 12:00:00"), tz="EST5EDT"),
as.POSIXct(c("1970-01-01 00:00:00", "1970-01-01 00:00:00"), tz="UTC"))
x1 <- as.dendrogram(hclust(dist(c(i=1,ii=2,iii=3,v=5,vi=6,vii=7))))
attr(cophenetic(x1), "Labels")
aa <- anova( lm(sr ~ ., data = LifeCycleSavings) )
op <- options(width = 50)
aa
options(width = 40)
aa ; options(op)
d <- data.frame(a=1)
d[integer(), "a"] <- 2
options(foo = 1)
print(options(foo = NULL))
raw <- "
function( a
, b=2
){a+b}"
p <- parse(text = raw)
getParseData(p)
set.seed(123); x <- runif(10); y <- rnorm(10)
op <- options(OutDec = ",")
fit <- lm(y ~ x)
summary(fit)
options(op)
L <- list(`a\\b` = 1, `a\\c` = 2, `a\bc` = "backspace")
setClass("foo", representation(`\\C` = "numeric"))
names(L)
unlist(L)
as.pairlist(L)
cat(names(L), "\n")
L
new("foo")
r <- matrix(,0,4, dimnames=list(Row=NULL, Col=paste0("c",1:4)))
r
t(r)
A <- array(dim=3:0, dimnames=list(D1=c("a","b","c"), D2=c("X","Y"), D3="I", D4=NULL))
A
A[,,"I",]
A[,,0,]
aperm(A, c(3:1,4))
aperm(A, c(1:2, 4:3))
unname(A)
format(A[,,1,])
aperm(A, 4:1)
make_long_name <- function(n)
{
paste0(rep("a", n), collapse = "")
}
setNames(TRUE, make_long_name(1000))
setNames(TRUE, make_long_name(1002))
setNames(TRUE, make_long_name(1003))
dd <- data.frame(F = factor(rep(c("A","B","C"), each = 3)), num = 1:9)
cs <- list(F = contr.sum(3, contrasts = FALSE))
a1 <- aov(num ~ F, data = dd, contrasts = cs)
model.tables(a1, "means")
t1 <- TukeyHSD(a1)
a2 <- aov(num ~ 0+F, data = dd, contrasts = cs)
model.tables(a2, "means")
t2 <- TukeyHSD(a2)
attr(t1, "orig.call") <- attr(t2, "orig.call")
stopifnot(all.equal(t1, t2))
substitute(a[1], list(a = quote(x * y)))
quote(`$`(a :: b, c))
quote(`[`(a $ b, c $ d))
quote(`$`(a[b], c))
quote(`^`(a[b], c[d]))
quote(`[`(a ^ b, c ^ d))
quote(`-`(a ^ b))
quote(`^`(-b, -d))
quote(`:`(-b, -d))
quote(`-`(a : b))
quote(`%in%`(a : b, c : d))
quote(`:`(a %in% b, c %in% d))
quote(`*`(a %in% b, c %in% d))
quote(`%in%`(a * b, c * d))
quote(`+`(a * b, c * d))
quote(`*`(a + b, c + d))
quote(`<`(a + b, c + d))
quote(`+`(a < b, c < d))
quote(`!`(a < b))
quote(`<`(!b, !d))
quote(`&`(!b, !d))
quote(`!`(a & b))
quote(`|`(a & b, c & d))
quote(`&`(a | b, c | d))
quote(`~`(a | b, c | d))
quote(`|`(a ~ b, c ~ d))
quote(`->`(a ~ b, d))
quote(`~`(a -> b, c -> d))
quote(`<-`(a, c -> d))
quote(`->`(a <- b, c))
quote(`=`(a, c <- d))
quote(`<-`(a, `=`(c, d)))
quote(`?`(`=`(a, b), `=`(c, d)))
quote(`=`(a, c ? d))
quote(`?`(a = b))
quote(`=`(b, ?d))
a <- alist(one = 1, two = )
dput(a)
quote(~~x)
quote(++x)
quote(--x)
quote(!!x)
quote(??x)
quote(~+-!?x)
quote(+!x)
x <- c(18000000, 18810924, 19091227, 19027233, 19310526, 19691228, NA)
x.Date <- as.Date(as.character(x), format = "%Y%m%d")
summary(x.Date)
DF.Dates <- data.frame(c1 = x.Date)
summary(DF.Dates)
DF.Dates$x1 <- 1:7
summary(DF.Dates)
DF.Dates$x2 <- c(1:6, NA)
summary(DF.Dates)
matrix(1i,2,13)
E <- expression(poly = x^3 - 3 * x^2)
str(E)
logi <- c(NA, logical(3), NA, !logical(2), NA)
summary(logi)
summary(logi[!is.na(logi)])
summary(TRUE)
ii <- as.integer(logi)
summary(ii)
summary(ii[!is.na(ii)])
summary(1L)
str(I(m <- matrix(pi*1:4, 2)))
sprintf("%d", 1)
sprintf("%d", NA_real_)
sprintf("%d", c(1,2))
sprintf("%d", c(1,NA))
sprintf("%d", c(NA,1))
assertErrorV( sprintf("%d", 1.1) )
assertErrorV( sprintf("%d", c(1.1,1)) )
assertErrorV( sprintf("%d", c(1,1.1)) )
assertErrorV( sprintf("%d", NaN) )
assertErrorV( sprintf("%d", c(1,NaN)) )
setNames(as.raw(1:3), c("a", "bbbb", "c"))
str(structure(c(a = 1, b = 2:7), color = "blue"))
tryCatch(stopifnot(exprs = {
all.equal(pi, 3.1415927)
2 < 2
cat("Kilroy was here!\n")
all(1:10 < 12)
"a" < "b"
}), error = function(e) e$message) -> M ; cat("Error: ", M, "\n")
tryCatch(stopifnot(exprs = {
all.equal(pi, 3.1415927)
{ cat("Kilroy was here!\n"); TRUE }
pi < 3
cat("whereas I won't be printed ...\n")
all(1:10 < 12)
"a" < "b"
}), error = function(e) e$message) -> M2 ; cat("Error: ", M2, "\n")
stopifnot(exprs = {
all.equal(pi, 3.1415927)
{ cat("\nKilroy was here! ... "); TRUE }
pi > 3
all(1:10 < 12)
"a" < "b"
{ cat("and I'm printed as well ...\n"); TRUE}
})
stopifnot(exprs = 2 == 2)
try(stopifnot(exprs = 1 > 2))
stopifnot(exprObject = expression(2 == 2, pi < 4))
tryCatch(stopifnot(exprObject = expression(
2 == 2,
{ cat("\n Kilroy again .."); TRUE },
pi < 4,
0 == 1,
{ cat("\n no way..\n"); TRUE })),
error = function(e) e$message) -> M3
cat("Error: ", M3, "\n")
print(t.test(1:28), digits = 3)
treeA <- trees
attr(treeA, "someA") <- 1:77
str(treeA)
if(capabilities("Rprof")) {
Rprof(tf <- tempfile("Rprof.out", tmpdir = getwd()), memory.profiling=TRUE, line.profiling=FALSE)
out <- lapply(1:10000, rnorm, n= 512)
Rprof(NULL)
if(interactive())
print(length(readLines(tf)))
op <- options(warn = 2)
for (cs in 1:21) s <- summaryRprof(tf, memory="tseries", chunksize=cs)
options(op)
unlink(tf)
}
a <- 1:12; (z <- a + a*1i); names(z) <- letters[seq_along(z)]; z
(ddd <- (function(...) environment())(1)$...)
dd2 <- (function(...) environment())(1)$...
stopifnot( identical(ddd, dd2) )
cm <- cbind(Estimate = 0, SE = 0, t = NaN, "Pr(>|t|)" = NaN)
printCoefmat(cm)
quote(1 + (if (TRUE) 2) + 3)
bquote(1 + .(quote(if (TRUE) 2)) + 3)
bquote(2 * .(quote(if (TRUE) 2 else 3)) / 4)
bquote(1 + ++.(quote(if (TRUE) 2)) + 3)
bquote(1^- . (quote(if (TRUE) 2)) + 3)
quote(`-`(1 + if(L) 2, 3+4))
bquote(1 + .(quote(if (TRUE) 2)) ^ 3)
bquote(1 + .(quote( f(if (TRUE) 2))) + 3)
bquote(1 + .(quote((2 + if (TRUE) 3))) + 4)
quote(a <- if (TRUE) 1)
quote(`^`(-1, 2))
quote((-1)^2)
quote(1^-2)
quote(1^-2 + 3)
quote(A + ~B + C ~ D)
quote(a$"b")
quote(`^`(1 + if(L) 2, 3))
quote(`*`(1 - if(L) 2 else 22, 3))
quote(`^`(1 + repeat 2, 3))
quote(`*`(1 + repeat 2, 3))
quote(`=`(1 + repeat 2, 3))
quote(`=`(1 + `+`(2, repeat 3), 4))
quote(`+`(`<-`(1, `=`(2, repeat 3)), 4))
quote(`+`(`:`(1, `=`(2, repeat 3)), 4))
quote(1 + +repeat 2)
quote(`<-`(1, +repeat 2))
quote(1^+repeat 2)
quote(`$`(1, +repeat 2))
quote(`^`(`+`(repeat 1, 2), 3))
quote(`+`(`+`(repeat 1, 2), 3))
quote(`+`(`+`(`+`(repeat 1, repeat 2), repeat 3), 4))
quote((-a)$b)
quote(`$`(-a, b))
quote((1 + 1)$b)
quote(`$`(1 + 1, b))
quote(`$`(1))
quote(`$`(1, 2, 3))
quote(`$`(1, NA_character_))
quote(`$`(1, if(L) 2))
quote(`$`(`$`(1, if(L) 2), 3))
quote(`$`(1 + repeat 2, 3))
quote(`=`(`$`(1, `$`(2, repeat 3)), 4)) |
s2c <- function(object, newname, env=.GlobalEnv)
{
if (missing(object))
{
if (iam("local"))
remoter_client_stop("must pass an object")
return(invisible())
}
test <- tryCatch(is.environment(env), error=identity)
if (isFALSE(test) || inherits(test, "error"))
{
if (iam("local"))
{
if (isFALSE(test))
remoter_client_stop("invalid environment")
else
remoter_client_stop(gsub(test, pattern="(.*: |\\n)", replacement=""))
}
return(invisible())
}
if (!missing(newname))
{
test <- try(is.character(newname), silent=TRUE)
if (inherits(test, "try-error") || !test || !identical(make.names(newname), newname))
{
if (iam("local"))
remoter_client_stop("invalid 'newname'")
return(invisible())
}
}
name <- as.character(substitute(object))
err <- ".__remoter_s2c_failure"
if (iam("local"))
{
value <- remoter_receive()
if (identical(value, err))
{
cat(paste0("Error: object '", name, "' not found on the server\n"))
return(invisible(FALSE))
}
if (!missing(newname))
name <- newname
assign(x=name, value=value, envir=env)
}
else if (iam("remote"))
{
val <- get0(name, envir=sys.frame(-1), ifnotfound=err)
remoter_send(data=val, send.more=TRUE)
}
return(invisible(TRUE))
} |
graph.adjacency.dense <- function(adjmatrix, mode=c("directed", "undirected", "max",
"min", "upper", "lower", "plus"),
weighted=NULL, diag=TRUE) {
mode <- igraph.match.arg(mode)
mode <- switch(mode,
"directed"=0,
"undirected"=1,
"max"=1,
"upper"=2,
"lower"=3,
"min"=4,
"plus"=5)
mode(adjmatrix) <- "double"
if (!is.null(weighted)) {
if (is.logical(weighted) && weighted) {
weighted <- "weight"
}
if (!is.character(weighted)) {
stop("invalid value supplied for `weighted' argument, please see docs.")
}
if (nrow(adjmatrix) != ncol(adjmatrix)) {
stop("not a square matrix")
}
on.exit( .Call(C_R_igraph_finalizer) )
res <- .Call(C_R_igraph_weighted_adjacency, adjmatrix,
as.numeric(mode), weighted, diag)
} else {
adjmatrix <- as.matrix(adjmatrix)
attrs <- attributes(adjmatrix)
adjmatrix <- as.numeric(adjmatrix)
attributes(adjmatrix) <- attrs
if (!diag) { diag(adjmatrix) <- 0 }
on.exit( .Call(C_R_igraph_finalizer) )
res <- .Call(C_R_igraph_graph_adjacency, adjmatrix, as.numeric(mode))
}
res
}
m2triplet <- get0("mat2triplet", asNamespace("Matrix"), inherits=FALSE)
if(!is.function(m2triplet))
m2triplet <- function(x) {
T <- as(x, "TsparseMatrix")
if(is(T, "nsparseMatrix"))
list(i = T@i + 1L, j = T@j + 1L)
else list(i = T@i + 1L, j = T@j + 1L, x = T@x)
}
mysummary <- function(x) do.call(cbind, m2triplet(x))
graph.adjacency.sparse <- function(adjmatrix, mode=c("directed", "undirected", "max",
"min", "upper", "lower", "plus"),
weighted=NULL, diag=TRUE) {
mode <- igraph.match.arg(mode)
if (!is.null(weighted)) {
if (is.logical(weighted) && weighted) {
weighted <- "weight"
}
if (!is.character(weighted)) {
stop("invalid value supplied for `weighted' argument, please see docs.")
}
}
mysummary <- Matrix::summary
if (nrow(adjmatrix) != ncol(adjmatrix)) {
stop("not a square matrix")
}
vc <- nrow(adjmatrix)
if(inherits(adjmatrix, "dgTMatrix")) {
adjmatrix = as(adjmatrix, "CsparseMatrix")
} else if (inherits(adjmatrix, "ddiMatrix")) {
adjmatrix = as(adjmatrix, "CsparseMatrix")
}
if (is.null(weighted) && mode=="undirected") { mode <- "max" }
if (mode == "directed") {
el <- mysummary(adjmatrix)
if (!diag) { el <- el[ el[,1] != el[,2], ] }
} else if (mode == "undirected") {
if (!is.null(weighted) && !Matrix::isSymmetric(adjmatrix)) {
stop("Please supply a symmetric matrix if you want to create a weighted graph with mode=UNDIRECTED.")
}
if (diag) {
adjmatrix <- Matrix::tril(adjmatrix)
} else {
adjmatrix <- Matrix::tril(adjmatrix, -1)
}
el <- mysummary(adjmatrix)
} else if (mode=="max") {
el <- mysummary(adjmatrix)
rm(adjmatrix)
if (!diag) { el <- el[ el[,1] != el[,2], ] }
el <- el[ el[,3] != 0, ]
w <- el[,3]
el <- el[,1:2]
el <- cbind( pmin(el[,1],el[,2]), pmax(el[,1], el[,2]) )
o <- order(el[,1], el[,2])
el <- el[o,,drop=FALSE]
w <- w[o]
if (nrow(el) > 1) {
dd <- el[2:nrow(el),1] == el[1:(nrow(el)-1),1] &
el[2:nrow(el),2] == el[1:(nrow(el)-1),2]
dd <- which(dd)
if (length(dd)>0) {
mw <- pmax(w[dd], w[dd+1])
w[dd] <- mw
w[dd+1] <- mw
el <- el[-dd,,drop=FALSE]
w <- w[-dd]
}
}
el <- cbind(el, w)
} else if (mode=="upper") {
if (diag) {
adjmatrix <- Matrix::triu(adjmatrix)
} else {
adjmatrix <- Matrix::triu(adjmatrix, 1)
}
el <- mysummary(adjmatrix)
rm(adjmatrix)
if (!diag) { el <- el[ el[,1] != el[,2], ] }
} else if (mode=="lower") {
if (diag) {
adjmatrix <- Matrix::tril(adjmatrix)
} else {
adjmatrix <- Matrix::tril(adjmatrix, -1)
}
el <- mysummary(adjmatrix)
rm(adjmatrix)
if (!diag) { el <- el[ el[,1] != el[,2], ] }
} else if (mode=="min") {
adjmatrix <- sign(adjmatrix) * sign(Matrix::t(adjmatrix)) * adjmatrix
el <- mysummary(adjmatrix)
if (!diag) { el <- el[ el[,1] != el[,2], ] }
el <- el[ el[,3] != 0, ]
w <- el[,3]
el <- el[,1:2]
el <- cbind( pmin(el[,1],el[,2]), pmax(el[,1], el[,2]) )
o <- order(el[,1], el[,2])
el <- el[o,]
w <- w[o]
if (nrow(el) > 1) {
dd <- el[2:nrow(el),1] == el[1:(nrow(el)-1),1] &
el[2:nrow(el),2] == el[1:(nrow(el)-1),2]
dd <- which(dd)
if (length(dd)>0) {
mw <- pmin(w[dd], w[dd+1])
w[dd] <- mw
w[dd+1] <- mw
el <- el[-dd,]
w <- w[-dd]
}
}
el <- cbind(el, w)
} else if (mode=="plus") {
adjmatrix <- adjmatrix + Matrix::t(adjmatrix)
if (diag) {
adjmatrix <- Matrix::tril(adjmatrix)
} else {
adjmatrix <- Matrix::tril(adjmatrix, -1)
}
el <- mysummary(adjmatrix)
if (diag) {
loop <- el[,1] == el[,2]
el[loop,3] <- el[loop,3] / 2
}
el <- el[ el[,3] != 0, ]
rm(adjmatrix)
}
if (!is.null(weighted)) {
res <- make_empty_graph(n=vc, directed=(mode=="directed"))
weight <- list(el[,3])
names(weight) <- weighted
res <- add_edges(res, edges=t(as.matrix(el[,1:2])), attr=weight)
} else {
edges <- unlist(apply(el, 1, function(x) rep(unname(x[1:2]), x[3])))
res <- graph(n=vc, edges, directed=(mode=="directed"))
}
res
}
graph_from_adjacency_matrix <- function(adjmatrix, mode=c("directed", "undirected", "max",
"min", "upper", "lower", "plus"),
weighted=NULL, diag=TRUE,
add.colnames=NULL, add.rownames=NA) {
if (inherits(adjmatrix, "Matrix")) {
res <- graph.adjacency.sparse(adjmatrix, mode=mode, weighted=weighted, diag=diag)
} else {
res <- graph.adjacency.dense(adjmatrix, mode=mode, weighted=weighted, diag=diag)
}
if (is.null(add.colnames)) {
if (!is.null(colnames(adjmatrix))) {
add.colnames <- "name"
} else {
add.colnames <- NA
}
} else if (!is.na(add.colnames)) {
if (is.null(colnames(adjmatrix))) {
warning("No column names to add")
add.colnames <- NA
}
}
if (is.null(add.rownames)) {
if (!is.null(rownames(adjmatrix))) {
add.rownames <- "name"
} else {
add.colnames <- NA
}
} else if (!is.na(add.rownames)) {
if (is.null(rownames(adjmatrix))) {
warning("No row names to add")
add.rownames <- NA
}
}
if (!is.na(add.rownames) && !is.na(add.colnames) &&
add.rownames == add.colnames ) {
warning("Same attribute for columns and rows, row names are ignored")
add.rownames <- NA
}
if (!is.na(add.colnames)) {
res <- set_vertex_attr(res, add.colnames, value=colnames(adjmatrix))
}
if (!is.na(add.rownames)) {
res <- set_vertex_attr(res, add.rownames, value=rownames(adjmatrix))
}
res
}
from_adjacency <- function(...) constructor_spec(graph_from_adjacency_matrix, ...) |
ConvertLongitude <- function(lon, group = NULL, from = NULL) {
checks <- makeAssertCollection()
assertNumeric(lon, add = checks, lower = -180, upper = 360)
assertVector(group, len = length(lon), null.ok = TRUE, add = checks)
assert_choice(from, c(180, 360), null.ok = TRUE)
reportAssertions(checks)
if (all(is.na(lon))) return(lon)
m <- min(lon, na.rm = TRUE)
if (m < -180) stopf("'lon' lower than 180 is not a valid longitude")
M <- max(lon, na.rm = TRUE)
if (M > 360) stopf("'lon' greater than 360 is not a valid longitude")
lon360 <- FALSE
lon180 <- FALSE
new.lon <- lon
if (is.null(from) || from == 180) {
lon180 <- which(lon < 0)
new.lon[lon180] <- new.lon[lon180] + 360
}
if (is.null(from) || from == 360) {
lon360 <- which(lon > 180)
new.lon[lon360] <- new.lon[lon360] - 360
}
if (!is.null(group)) {
group.c <- as.character(group)
group.c[lon360 | lon180] <- paste0(group.c[lon360 | lon180], "_2")
if (is.factor(group)) {
group.c <- factor(group.c)
}
return(list(lon = new.lon, group = group.c))
}
return(new.lon)
} |
library(particle.swarm.optimisation)
set.seed(42)
fitness_function <- function(values){
a <- values[1]
b <- values[2]
difference <- 25 - (a * 2 + b * 4 + 10)
fitness <- 1 - abs(difference)
return(fitness)
}
values_ranges <- list(c(-100,100),c(-100,100))
swarm <- ParticleSwarm$new(pop_size = 50,
values_names = c('a',"b"),
fitness_function = fitness_function,
max_it = 50,
acceleration_coefficient_range = list(c(0.5,1),c(0.5,1)),
inertia = 0.5,
range_of_values = values_ranges)
if(interactive()){
swarm$run(verbose = FALSE,
plot = TRUE,
save_file = FALSE)
} else {
swarm$run(verbose = FALSE,
plot = FALSE,
save_file = FALSE)
}
print(swarm)
print("solution: ")
print(swarm$swarm_best_values) |
source("ESEUR_config.r")
library("survival")
pal_col=rainbow(3)
ISR=read.csv(paste0(ESEUR_dir, "survival/vulnerabilities/patching_published-ISR.csv.xz"), as.is=TRUE)
ISR$cert_pub=as.Date(ISR$cert_pub, format="%Y-%m-%d")
ISR$other_pub=as.Date(ISR$other_pub, format="%Y-%m-%d")
ISR$notify=as.Date(ISR$notify, format="%Y-%m-%d")
ISR$patch=as.Date(ISR$patch, format="%Y-%m-%d")
ISR$publish=as.Date(ISR$publish, format="%Y-%m-%d")
map_vendor=function(to_name, from_name)
{
ISR$vendor[ISR$vendor == from_name] <<- to_name
}
map_vendor("Apache", "Apache Software Foundation")
map_vendor("apple", "Apple Computer Inc.")
map_vendor("BEA", "BEA Systems Inc.")
map_vendor("BSCW", "BSCW.gmd")
map_vendor("Cisco", "Cisco Systems Inc.")
map_vendor("Conectiva", "Conectiva Linux")
map_vendor("EFTP", "EFTP Development Team")
map_vendor("gentoo", "Gentoo Linux")
map_vendor("GNU glibc", "GNU Libgcrypt")
map_vendor("Hitachi", "Hitachi Data Systems")
map_vendor("HP", "Hewlett-Packard Company")
map_vendor("Ipswitch", "Ipswitch Inc.")
map_vendor("Lotus", "Lotus Software")
map_vendor("Macromedia", "Macromedia Inc.")
map_vendor("mandrakesoft", "MandrakeSoft")
map_vendor("Microsoft", "Microsoft Corporation")
map_vendor("Nbase", "Nbase-Xyplex")
map_vendor("Nbase", "NBase-Xyplex")
map_vendor("openpkg", "Openpgk")
map_vendor("openpkg", "The OpenPKG Project")
map_vendor("Oracle", "Oracle Corporation")
map_vendor("Redhat", "Red Hat Inc.")
map_vendor("SCO", "The SCO Group")
map_vendor("sco", "The SCO Group (SCO Linux)")
map_vendor("sco", "The SCO Group (SCO UnixWare)")
map_vendor("sendmail", "Sendmail Inc.")
map_vendor("sendmail", "The Sendmail Consortium")
map_vendor("Sun", "Sun Microsystems Inc.")
map_vendor("suse", "SuSE Inc.")
map_vendor("Symantec", "Symantec Corporation")
map_vendor("trustix", "Trusix")
map_vendor("trustix", "Trustix Secure Linux")
map_vendor("Washington University", "University of Washington")
map_vendor("yellow dog", "Yellow Dog Linux")
ISR$vendor=tolower(ISR$vendor)
end_date=as.Date("11-Aug-2003", format="%d-%b-%Y")
ISR$is_censored=is.na(ISR$patch)
ISR$patch[ISR$is_censored]=end_date
ISR$patch_days=as.numeric(ISR$patch-ISR$notify)
ISR$notify_days=as.numeric(ISR$publish-ISR$notify)
ISR$disc=(ISR$patch > ISR$publish)
ISR_priv=subset(ISR, notify < publish)
ISR_priv_priv=subset(ISR_priv, !(patch > publish))
ISR_priv_disc=subset(ISR_priv, patch > publish)
ISR_disc=subset(ISR, notify == publish)
p_sfit_priv_priv=survfit(Surv(ISR_priv_priv$patch_days, !ISR_priv_priv$is_censored) ~ 1)
plot(p_sfit_priv_priv, xlim=c(0, 600), col=pal_col[1],
xaxs="i", yaxs="i",
xlab="Time to release patch", ylab="Survival rate\n")
p_sfit_priv_disc=survfit(Surv(ISR_priv_disc$patch_days, !ISR_priv_disc$is_censored) ~ 1)
lines(p_sfit_priv_disc, col=pal_col[2])
p_sfit_disc=survfit(Surv(ISR_disc$patch_days, !ISR_disc$is_censored) ~ 1)
lines(p_sfit_disc, col=pal_col[3])
legend(x="topright", legend=c("Private, patched and public", "Public then patched", "Private, public then patched"), bty="n", fill=pal_col, cex=1.2) |
context("WMWssp")
x <- c(315,375,356,374,412,418,445,403,431,410,391,475,379)
y <- x - 20
result_WMWsspN <- 111.3719511
result_WMWsspp <- 0.3491124
result_power <- 0.9
suppressWarnings(RNGversion("3.5.0"))
set.seed(1)
result_simpower <- WMWssp::WMWssp(x, y, alpha = 0.05, power = 0.8, t = 1/2, simulation = TRUE, nsim = 10)$result[3, ]
test_that("function WMWssp", {
expect_equivalent(WMWssp::WMWssp(x, y, alpha = 0.05, power = 0.8, t = 1/2)$result[4,], result_WMWsspN, tolerance=1e-4)
expect_equivalent(WMWssp::WMWssp(x, y, alpha = 0.05, power = 0.8, t = 1/2)$result[3,], result_WMWsspp, tolerance=1e-4)
expect_output(print(WMWssp::WMWssp(x, y, alpha = 0.05, power = 0.8, t = 1/2)))
expect_output(summary(WMWssp::WMWssp(x, y, alpha = 0.05, power = 0.8, t = 1/2)))
expect_equivalent(result_power, result_simpower)
}) |
"identify.regul" <-
function(x, series=1, col=3, label="
labels <- rep(label, length.out=length(x$xini))
i <- series
if (i > ncol(x$yini))
stop("This series does not exist")
n <- identify(x$xini, x$yini[,i], labels=labels, col=col, ...)
n.vec <- rep(0, length.out=length(x$xini))
n.vec[n] <- 1
n.vec
} |
library(glmmTMB)
library(DHARMa)
library(mgcv)
f2 <- function(x) 0.2 * x^11 * (10 * (1 - x))^6 + 10 *
(10 * x)^3 * (1 - x)^10
n <- 300
x <- runif(n)
mu <- exp(f2(x)/3+.1);
x <- x*10 - 4
y <- rTweedie(mu,p=1.5,phi=1.3)
fit <- gam(y~s(x,k=20),family=Tweedie(p=1.5))
summary(fit)
res = simulateResiduals(fit)
plot(res)
summary(b)
y <- rgamma(100,shape=5)
x <- 1:100
fit = glmmTMB(y~x,family=tweedie())
res = simulateResiduals(fit)
plot(res)
require(statmod)
require(tweedie)
fit = glm(y~x,family=tweedie(var.power=1,link.power=1)) |
progress_multi <- function(i, labels, count, progress) {
label <- format(labels[[i]], width = max(nchar(labels)), justify = "right")
if (count) {
is <- format(i, width = nchar(length(labels)))
prefix <- sprintf("[%s/%s] %s", is, length(labels), label)
} else {
prefix <- label
}
bar <- NULL
type <- "down"
seen <- 0
if (progress) {
callback <- function(down, up) {
if (type == "down") {
total <- down[[1L]]
now <- down[[2L]]
} else {
total <- up[[1L]]
now <- up[[2L]]
}
if (total == 0 && now == 0) {
bar <<- NULL
seen <<- 0
return(TRUE)
}
if (is.null(bar)) {
if (total == 0) {
fmt <- paste0(prefix, " [ :bytes in :elapsed ]")
total <- 1e8
} else {
fmt <- paste0(prefix, " [:percent :bar]")
}
bar <<- progress::progress_bar$new(fmt, total,
clear = TRUE,
show_after = 0
)
}
if (total == 0) {
bar$tick(now)
} else {
bar$tick(now - seen)
seen <<- now
}
TRUE
}
} else {
callback <- function(down, up) {
TRUE
}
}
list(
callback = callback,
prefix = prefix
)
}
fetch_cran_rds_file <- function(file = c("details", "results", "flavors", "issues"),
dest = tempdir(), protocol = c("https", "http"),
overwrite = FALSE, file_prefix = NULL,
progress = TRUE, ...) {
file <- match.arg(file)
protocol <- match.arg(protocol)
is_ftp <- if (identical(protocol, "ftp")) "/pub/R/" else character(0)
file <- paste0("check_", file, ".rds")
dest_file <- file.path(dest, paste0(file_prefix, file))
if (!(file.exists(dest_file) &&
file.info(dest_file, extra_cols = FALSE)$size > 0) ||
overwrite) {
file_cran_url <- paste0(cran_url(protocol), is_ftp, "/web/checks/", file)
if (interactive()) {
pb <- progress_multi(
i = 1, labels = list(paste("Downloading", file)), count = FALSE,
progress = requireNamespace("progress", quietly = TRUE) && progress
)
} else {
pb <- NULL
}
d_status <- httr::GET(
url = file_cran_url,
httr::write_disk(dest_file, overwrite = overwrite),
httr::config(progressfunction = pb$callback), ...
)
if (!identical(httr::status_code(d_status), 200L)) {
unlink(dest_file)
stop("Can't get ", file_cran_url, " (status code: ", httr::status_code(d_status), ")", call. = FALSE)
}
}
invisible(dest_file)
}
check_cran_rds_file <- function(file, return_logical = FALSE) {
if (!file.exists(file)) {
stop(file, " can't be found...", call. = FALSE)
}
if (file.info(file, extra_cols = FALSE)$size < 100) {
stop(file, " is corrupted. Delete it and retry.")
}
res <- try(readRDS(file = file), silent = TRUE)
if (inherits(res, "try-error")) {
stop(file, " can't be read. Delete it and retry.")
} else if (return_logical) {
return(TRUE)
} else {
res
}
}
read_cran_rds_file <- function(file) {
res <- check_cran_rds_file(file)
names(res) <- tolower(names(res))
class(res) <- c("cran_db", class(res))
res
}
get_cran_rds_file <- function(file, ...) {
if (grepl("\\.rds$", file, ignore.case = TRUE) &&
file.exists(file)) {
f <- file
} else {
f <- fetch_cran_rds_file(file, ...)
}
read_cran_rds_file(f)
}
read_crandb_from_email <- function(email, file = "results", ...) {
crandb <- get_cran_rds_file(file = file, ...)
maintainer <- tolower(crandb$maintainer)
idx <- lapply(tolower(email), function(x) {
grepl(paste0("<", x, ">"), maintainer, fixed = TRUE)
})
idx <- Reduce("+", idx)
res <- crandb[as.logical(idx), ]
class(res) <- c("crandb", class(res))
res
}
read_crandb_from_pkg <- function(pkg, file = "results", ...) {
crandb <- get_cran_rds_file(file = file, ...)
res <- crandb[crandb[["package"]] %in% pkg, ]
class(res) <- c("crandb", class(res))
res
}
add_other_issues_crandb <- function(tbl, ...) {
issues <- get_cran_rds_file("issues", ...)
res <- vapply(tbl[["package"]], function(x) {
pkg_issues <- issues[issues$package == x, ]
if (nrow(pkg_issues) > 0) {
paste(pkg_issues$kind, collapse = ", ")
} else {
""
}
}, character(1), USE.NAMES = FALSE)
tbl$has_other_issues <- nchar(res) > 0
tbl
} |
minimal <-
function(z) UseMethod("minimal") |
distr_to_xml <- function(
distr,
beauti_options = create_beauti_options()
) {
beautier::check_beauti_options(beauti_options)
text <- NULL
id <- distr$id
if (!beautier::is_id(id)) {
stop("distribution must have an ID")
}
if (beautier::is_beta_distr(distr)) {
text <- c(text, beautier::distr_to_xml_beta(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_exp_distr(distr)) {
text <- c(text, beautier::distr_to_xml_exp(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_gamma_distr(distr)) {
text <- c(text, beautier::gamma_distr_to_xml(gamma_distr = distr, beauti_options = beauti_options))
} else if (beautier::is_inv_gamma_distr(distr)) {
text <- c(text, beautier::distr_to_xml_inv_gamma(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_laplace_distr(distr)) {
text <- c(text, beautier::distr_to_xml_laplace(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_log_normal_distr(distr)) {
text <- c(text, beautier::distr_to_xml_log_normal(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_normal_distr(distr)) {
text <- c(text, beautier::distr_to_xml_normal(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_one_div_x_distr(distr)) {
text <- c(text, beautier::distr_to_xml_one_div_x(distr = distr, beauti_options = beauti_options))
} else if (beautier::is_poisson_distr(distr)) {
text <- c(text, beautier::distr_to_xml_poisson(distr = distr, beauti_options = beauti_options))
} else {
testit::assert(beautier::is_uniform_distr(distr))
text <- c(text, beautier::distr_to_xml_uniform(distr = distr, beauti_options = beauti_options))
}
testit::assert(beautier::is_xml(text))
text
}
distr_to_xml_beta <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_beta_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<Beta id=\"Beta.", id, "\" name=\"distr\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$alpha)
)
)
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$beta)
)
)
text <- c(text, paste0("</Beta>"))
text
}
distr_to_xml_exp <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_exp_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<Exponential ",
"id=\"Exponential.", id, "\" name=\"distr\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$mean)
)
)
text <- c(text, paste0("</Exponential>"))
text
}
distr_to_xml_inv_gamma <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_inv_gamma_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<InverseGamma ",
"id=\"InverseGamma.", id, "\" name=\"distr\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$alpha)
)
)
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$beta)
)
)
text <- c(text, paste0("</InverseGamma>"))
text
}
distr_to_xml_laplace <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_laplace_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<LaplaceDistribution ",
"id=\"LaplaceDistribution.", id, "\" name=\"distr\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$mu)
)
)
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$scale)
)
)
text <- c(text, paste0("</LaplaceDistribution>"))
text
}
distr_to_xml_log_normal <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_log_normal_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<LogNormal ",
"id=\"LogNormalDistributionModel.", id, "\" name=\"distr\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$m)
)
)
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$s)
)
)
text <- c(text, paste0("</LogNormal>"))
text
}
distr_to_xml_normal <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_normal_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<Normal ",
"id=\"Normal.", id, "\" name=\"distr\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$mean)
)
)
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$sigma)
)
)
text <- c(text, paste0("</Normal>"))
text
}
distr_to_xml_one_div_x <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_one_div_x_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<OneOnX ",
"id=\"OneOnX.", id, "\" name=\"distr\"/>"))
text
}
distr_to_xml_poisson <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_poisson_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
text <- c(text, paste0("<distr ",
"id=\"Poisson.", id, "\" ",
"spec=\"beast.math.distributions.Poisson\">"))
text <- c(text,
beautier::indent(
beautier::parameter_to_xml(distr$lambda),
)
)
text <- c(text, paste0("</distr>"))
text
}
distr_to_xml_uniform <- function(
distr,
beauti_options = create_beauti_options()
) {
testit::assert(beautier::is_uniform_distr(distr))
beautier::check_beauti_options(beauti_options)
id <- distr$id
testit::assert(beautier::is_id(id))
text <- NULL
line_begin <- paste0("<Uniform id=\"Uniform.", id, "\" name=\"distr\"")
line_end <- "/>"
upper <- distr$upper
if (beautier::is_one_na(upper)) {
text <- c(text, paste0(line_begin, line_end))
} else if (is.infinite(upper)) {
text <- c(text, paste0(line_begin, " upper=\"Infinity\"", line_end))
} else {
text <- c(text, paste0(line_begin, " upper=\"", upper, "\"", line_end))
}
text
} |
fit_Exptrawl <- function(x,Delta=1, plotacf=FALSE,lags=100){
my_acf <- TSA::acf(x,plot=F)
lambda <- -base::log(my_acf$acf[1])/Delta
if(plotacf){
tt <- (1:lags)
TSA::acf(x,lag.max=lags,main = "", ylab="ACF", xlab="Lags",drop.lag.0 = TRUE)
graphics::lines(tt, acf_Exp((tt*Delta), lambda), lty =1,col=2, lwd=2)
}
return (list("lambda"=lambda,"LM"=1/lambda))
}
fit_supIGtrawl <- function(x,Delta=1,GMMlag=5,plotacf=FALSE,lags=100){
my_acf <- TSA::acf(x,plot=F)
fit_supIGtrawl_foroptim <- function(y){
delta <- y[1]
gamma <-y[2]
lag <- GMMlag
lss <- 0
for(i in 1:lag)
{
Cor <- acf_supIG(Delta*i,delta,gamma)
lss <- lss+(my_acf$acf[i] - Cor)^2
}
lss
}
o <- DEoptim::DEoptim(fit_supIGtrawl_foroptim,c(0,0),c(100,100),control=DEoptim::DEoptim.control(itermax = 1000, trace = FALSE))
if(plotacf){
tt <- (1:lags)
TSA::acf(x,lag.max=lags,main = "", ylab="ACF", xlab="Lags",drop.lag.0 = TRUE)
graphics::lines(tt, acf_supIG(tt*Delta,o$optim$bestmem[1],o$optim$bestmem[2]), lty =1,col=2, lwd=2)
}
return(list("delta"=as.numeric(o$optim$bestmem[1]), "gamma"=as.numeric(o$optim$bestmem[2]), "LM"=as.numeric(o$optim$bestmem[2])/as.numeric(o$optim$bestmem[1])))
}
fit_LMtrawl <- function(x,Delta=1, GMMlag=5, plotacf=FALSE,lags=100){
my_acf <- TSA::acf(x,plot=F)
fit_LMtrawl_foroptim <- function(y){
alpha <- y[1]
Hurst <-y[2]
lag <- GMMlag
lss <- 0
for(i in 1:lag)
{
Cor <- acf_LM(Delta*i,alpha, Hurst)
lss <- lss+(my_acf$acf[i] - Cor)^2
}
lss
}
o <- DEoptim::DEoptim(fit_LMtrawl_foroptim,c(0,0),c(100,100),control=DEoptim::DEoptim.control(itermax = 1000, trace = FALSE))
if(plotacf){
tt <- (1:lags)
TSA::acf(x,lag.max=lags,main = "", ylab="ACF", xlab="Lags",drop.lag.0 = TRUE)
graphics::lines(tt, acf_LM(tt*Delta,o$optim$bestmem[1],o$optim$bestmem[2]), lty =1,col=2, lwd=2)
}
return(list("alpha"=as.numeric(o$optim$bestmem[1]), "H"=as.numeric(o$optim$bestmem[2]), "LM"=as.numeric(o$optim$bestmem[1])/(as.numeric(o$optim$bestmem[2])-1)))
}
fit_DExptrawl <- function(x,Delta=1, GMMlag=5, plotacf=FALSE,lags=100){
my_acf <- TSA::acf(x,plot=F)
fit_DExptrawl_foroptim <- function(y){
w <- y[1]
memory1 <-y[2]
memory2 <-y[3]
Delta <- 1
my_acf <- TSA::acf(x,plot=F)
lag <- GMMlag
lss <- 0
for(i in 1:lag)
{
Cor <- acf_DExp(Delta*i,w,memory1,memory2)
lss <- lss+(my_acf$acf[i] - Cor)^2
}
lss
}
o <- DEoptim::DEoptim(fit_DExptrawl_foroptim,c(0,0,0),c(0.5,100,100),control=DEoptim::DEoptim.control(itermax = 1000, trace = FALSE))
if(plotacf){
tt <- (1:lags)
TSA::acf(x,lag.max=lags,main = "", ylab="ACF", xlab="Lags",drop.lag.0 = TRUE)
graphics::lines(tt, acf_DExp(tt*Delta,o$optim$bestmem[1],o$optim$bestmem[2],o$optim$bestmem[3]), lty =1,col=2, lwd=2)
}
return(list("w"=as.numeric(o$optim$bestmem[1]), "lambda_1"=as.numeric(o$optim$bestmem[2]), "lambda_2"=as.numeric(o$optim$bestmem[3]),"LM"=as.numeric(o$optim$bestmem[1])/as.numeric(o$optim$bestmem[2])+(1-as.numeric(o$optim$bestmem[1]))/as.numeric(o$optim$bestmem[3])))
} |
Hx_root.f <- function(Hx,Dx,Hm,Dm,mHt,sHt,par.lme, Rfn, ...){
return(E_DHx_HmDm_HT.f( Hx, Hm, Dm, mHt, sHt = 0, par.lme, Rfn)$DHx - Dx)
} |
seqeid <- function(eseq, s) {
TraMineR.check.depr.args(alist(eseq = s))
tmrsequenceid.internal <- function(eseq) {
if(is.eseq(eseq)){
return(.Call(C_tmrsequencegetid, eseq))
}
return(NA)
}
if(is.seqelist(eseq)){
return(as.integer(sapply(unlist(eseq),tmrsequenceid.internal)))
}else if(is.eseq(eseq)){
return(tmrsequenceid.internal(eseq))
}else{
stop("eseq should be a seqelist. See help on seqecreate.")
}
return(NA)
} |
plot_bidev <- function (x, dev1, dev2, breaks = c(25, 50, 100),
dev1.lab = NULL, dev2.lab = NULL, lib.var = NULL,
lib.val = NULL, cex.lab = 1, cex.axis = .7, cex.pt = .5,
cex.names =.8, pos.names = 4){
d <- breaks
d <- (d/100) + 1
dVal <- c(100 * 1/d[3], 100 * 1/d[3], 100 * 1/d[2], 100 * 1/d[1], 100,
100 * d[1], 100 * d[2], 100 * d[3], 100 * d[3])
minVal <- min(c(min(x[[dev1]], na.rm = TRUE), min(x[[dev2]], na.rm = TRUE)))
maxVal <- max(c(max(x[[dev1]], na.rm = TRUE), max(x[[dev2]], na.rm = TRUE)))
if(minVal < dVal[1]){
dVal[1] <- minVal
}
if(maxVal > dVal[9]){
dVal[9] <- maxVal
}
colvec <- c("lightgrey", "
"
"
opar <- par(mar = c(4,4,4,4), pty = "s")
on.exit(par(opar), add = TRUE)
plot((dVal[1] - 0.1) : (dVal[9] + 0.5),
(dVal[1] - 0.1) : (dVal[9] + 0.5),
xaxt = "n", yaxt = "n", xaxs = "i", yaxs = "i",
type = "n", xlab = dev1.lab, ylab = dev2.lab,
cex.lab = cex.lab, log = "xy")
axis(1, at = round(c(minVal,dVal, maxVal), 0), cex.axis = cex.axis)
axis(2, at = round(c(minVal, dVal,maxVal), 0), cex.axis = cex.axis)
polygon(x = c(dVal[4], 100, dVal[6] ,100),
y = c(100, dVal[4], 100, dVal[6]), col = colvec[1], border = NA)
polygon(x = c(100, 100, dVal[7], dVal[6]),
y = c(dVal[6], dVal[7], 100, 100), col = colvec[2], border = NA)
polygon(x = c(100, 100, dVal[8], dVal[7]),
y = c(dVal[7], dVal[8], 100, 100), col = colvec[3], border = NA)
polygon(x = c(100, 100, dVal[9], dVal[9], dVal[8]),
y = c(dVal[8], dVal[9], dVal[9], 100, 100), col = colvec[4], border = NA)
polygon(x = c(dVal[6], dVal[7], 100, 100),
y = c(100, 100, dVal[3], dVal[4]), col = colvec[5], border = NA)
polygon(x = c(dVal[7], dVal[8], 100, 100),
y = c(100, 100,dVal[2], dVal[3]), col = colvec[6], border = NA)
polygon(x = c(dVal[8], dVal[9], dVal[9], 100, 100),
y = c(100, 100, dVal[1], dVal[1], dVal[2]), col = colvec[7], border = NA)
polygon(x = c(dVal[3], dVal[4], 100, 100),
y = c(100, 100, dVal[4], dVal[3]), col = colvec[8], border = NA)
polygon(x = c(dVal[3], dVal[2], 100, 100),
y = c(100, 100, dVal[2], dVal[3]), col = colvec[9], border = NA)
polygon(x = c(dVal[2], dVal[1], dVal[1], 100, 100),
y = c(100, 100, dVal[1], dVal[1], dVal[2]), col = colvec[10], border = NA)
polygon(x = c(dVal[4], dVal[3], 100, 100),
y = c(100, 100, dVal[7], dVal[6]), col = colvec[11], border = NA)
polygon(x = c(dVal[3], dVal[2], 100, 100),
y = c(100, 100, dVal[8], dVal[7]), col = colvec[12], border = NA)
polygon(x = c(dVal[2], dVal[1], dVal[1], 100, 100),
y = c(100, 100, dVal[9], dVal[9], dVal[8]), col = colvec[13], border = NA)
abline (h = dVal, col = "white", lwd = 0.25, lty = 3)
abline (v = dVal, col = "white", lwd = 0.25, lty = 3)
abline (h = 100, col = "white", lwd = 1, lty = 1)
abline (v = 100, col = "white", lwd = 1, lty = 1)
if(class(x)[1] == "sf"){
x <- st_set_geometry(x, NULL)
}
points(x = x[,dev1], y= x[,dev2], type="p", pch = 16, col = "black", cex = cex.pt)
if(!is.null(lib.var)) {
y <- x[x[,lib.var] %in% lib.val,]
points(x = y[,dev1], y= y[,dev2], type="p", pch = 23, bg= "white", col = "red", cex= cex.pt*3.5)
text(x = y[,dev1], y= y[,dev2], labels = y[,lib.var], cex = cex.names, pos = pos.names, col = "white")
}
} |
SRM_CREATE_PARAMETER_LISTS <- function(parm.table, ngroups)
{
mmNames <- attr(parm.table, "mmNames")
parm_list_U <- as.list( seq_len(ngroups) )
parm_list_D <- as.list( seq_len(ngroups) )
for (hh in 1:2){
for (gg in seq_len(ngroups)){
ii <- ngroups*(hh-1) + gg
NM <- length(mmNames[[ii]])
parm_list0 <- as.list( seq_len(NM) )
for (mm in 1:NM){
name_mm <- mmNames[mm]
mat_mm <- matrix(0, nrow=attr(parm.table,"mmRows")[[ii]][mm],
ncol=attr(parm.table,"mmCols")[[ii]][mm] )
parm_list0[[mm]] <- mat_mm
}
names(parm_list0) <- mmNames[[ii]]
if (hh==1){
parm_list_U[[gg]] <- parm_list0
}
if (hh==2){
parm_list_D[[gg]] <- parm_list0
}
}
}
res <- list( parm_list_U = parm_list_U, parm_list_D = parm_list_D)
return(res)
} |
ee = expect_equal
d = deque(1, 2, 3, 4)
ee(rotate(d), deque(4, 1, 2, 3))
ee(rotate(d, 2), deque(3, 4, 1, 2))
ee(rotate(d, -1), deque(2, 3, 4, 1))
ref_rotate(d)
ee(d, deque(4, 1, 2, 3))
ref_rotate(d, -1)
ee(d, deque(1, 2, 3, 4)) |
mc_err_orth <- function(x,
x_err,
y,
y_err,
X,
Y,
MC = 1000){
xmat <- matrix(rnorm(MC * length(x)), nrow = length(x)) * x_err + matrix(rep(x, MC), nrow = length(x))
ymat <- matrix(rnorm(MC * length(y)), nrow = length(y)) * y_err + matrix(rep(y, MC), nrow = length(y))
Xarray <- sqrt(
((outer(xmat, X, FUN = "-") - mean(outer(xmat, X, FUN = "-"))) / sd(outer(xmat, X, FUN = "-"))) ^ 2 +
((outer(ymat, Y[, 2], FUN = "-") - mean(outer(ymat, Y[, 2], FUN = "-"))) / sd(outer(ymat, Y[, 2], FUN = "-"))) ^ 2
)
posmat <- apply(Xarray, c(1,2), which.min)
Xsimmat <- matrix(X[posmat], nrow = length(x))
X_comb <- apply(Xsimmat, 1, mean)
Ysimmat <- matrix(Y[posmat, 2], nrow = length(y))
Y_comb <- approx(
x = X,
y = Y[, 2],
xout = X_comb,
method = "linear",
rule = 2
)
X_err_comb <- apply(Xsimmat, 1, sd)
Y_err_comb <- apply(Ysimmat, 1, sd)
result <- data.frame(
X = X_comb,
X_err = X_err_comb,
Y = Y_comb$y,
Y_err = Y_err_comb
)
return(result)
} |
dib.fun<-function(X,N){
data.frame(dib=var(X)/(mean(X)*(1-mean(X)/N)))
} |
OneComp_Volume_RateConstant<-function(V1,k10,
V1.sd=NA,k10.sd=NA,covar=c(V1k10=0),...){
if(is.na(covar[1])) covar<-0
V1.var = (V1.sd)^2
k10.var = (k10.sd)^2
Vdss<-V1
Vdss.sd<-V1.sd
Cl1<-V1*k10
sigma<-matrix(as.numeric(c(V1.var,covar[1],covar[1],k10.var)),2,2,byrow=T)
Cl1_deriv<-as.matrix(attr(eval(stats::deriv(~V1*k10,c("V1","k10"))),
"gradient"))
Cl1.sd<-sqrt(Cl1_deriv %*% sigma %*% t(Cl1_deriv))
t_alpha<-log(2)/k10
t_alpha_deriv<-as.matrix(attr(eval(stats::deriv(~log(2)/k10,"k10")),
"gradient"))
t_alpha.sd<-sqrt(t_alpha_deriv * k10.var *t_alpha_deriv)
true_A<-1/V1
true_A_deriv<-attr(eval(stats::deriv(~1/V1,"V1")),"gradient")
true_A.sd<-sqrt(true_A_deriv* V1.var * true_A_deriv)
frac_A<-1
frac_A.sd<-ifelse(is.na(V1.sd),NA,0)
alpha<-k10
alpha.sd<-k10.sd
if(is.na(V1[1])){
param = rep(NA,8)
sd = rep(NA,8)
} else{
param = c(V1,k10,Cl1,t_alpha,Vdss,true_A,frac_A,alpha)
sd = c(V1.sd,k10.sd,Cl1.sd,t_alpha.sd,Vdss.sd,true_A.sd,frac_A.sd,alpha.sd)
}
result = data.frame(Parameter=c("V1","k10","Cl1","t_alpha","Vdss",
"True_A","Frac_A","alpha"),
Estimate=param, Std.err=sd)
row.names(result) <- c("V1","k10","Cl1","t_alpha","Vdss",
"True_A","Frac_A","alpha")
result<-result[c("Vdss","V1","Cl1","k10","alpha","t_alpha",
"True_A","Frac_A"),]
return(result)
} |
`print.ifit` <-
function(x, visible = TRUE, sort_by = c("none", "p", "outfit_MSQ", "infit_MSQ", "outfit_t", "infit_t", "discrim"),
decreasing = FALSE, digits = 3, ...)
{
sort_by <- match.arg(sort_by, c("none", "p", "outfit_MSQ", "infit_MSQ", "outfit_t", "infit_t", "discrim"), several.ok = FALSE)
pvalues <- 1-pchisq(x$i.fit,x$i.df-1)
coef.table <- cbind(round(x$i.fit,digits), x$i.df-1, round(pvalues,digits), round(x$i.outfitMSQ, digits),
round(x$i.infitMSQ, digits),round(x$i.outfitZ, digits),round(x$i.infitZ, digits),
round(x$i.disc, digits))
colnames(coef.table) <- c("Chisq","df","p-value","Outfit MSQ", "Infit MSQ", "Outfit t", "Infit t", "Discrim")
rownames(coef.table) <- names(x$i.fit)
if (length(sort_by) == 6) sort_by <- "none"
if (sort_by != "none") {
sort_by <- sort_by[1]
if (sort_by == "p") sortcol <- 3
if (sort_by == "outfit_MSQ") sortcol <- 4
if (sort_by == "infit_MSQ") sortcol <- 5
if (sort_by == "outfit_t") sortcol <- 6
if (sort_by == "infit_t") sortcol <- 7
if (sort_by == "discrim") sortcol <- 8
if (sort_by != "discrim") {
ind <- order(abs(coef.table[, sortcol]), decreasing = decreasing)
} else {
ind <- order(coef.table[, sortcol], decreasing = decreasing)
}
coef.table <- coef.table[ind,]
}
if (visible){
cat("\nItemfit Statistics: \n")
print(coef.table)
cat("\n")
}
invisible(coef.table)
} |
time_stamp <- function(n, x = seq(0, 23, by = 1), prob = NULL, random = FALSE,
name = "Time"){
out <- sample(x = x, size = n, replace = TRUE, prob = prob)
if (!random) out <- sort(out)
varname(sec2hms(out), name)
} |
expit <- function(x) exp(x)/(1+exp(x))
library(pseval)
library(survival)
gen_binary <- function(n){
Z <- rbinom(n, 1, .5)
X <- rbinom(n, 1, .35)
ps.0 <- expit(X + rnorm(n, sd = .1))
ps.1 <- expit(2 + X + rnorm(n, sd = .1))
S.0 <- rbinom(n, 1, ps.0)
S.1 <- rbinom(n, 1, ps.1)
risk.obs <- (1 - 0.5 * S.1 - 0 * Z - 1 * S.1 * Z)
risk.0 <- (1 - 0.5 * S.1)
risk.1 <- (1 - 1.5 * S.1)
Y.0 <- rbinom(n, 1, expit(risk.0))
Y.1 <- rbinom(n, 1, expit(risk.1))
Y.obs <- ifelse(Z == 1, Y.1, Y.0)
S.1[Z == 0] <- NA
S.0[Z == 1] <- NA
S.obs <- ifelse(Z == 1, S.1, S.0)
data.frame(Z, BIP = X, S.obs, Y.obs)
}
swoop <- function(psdesign){
c(psdesign$estimates$par, psdesign$estimates$convergence == 0)
}
true.par <- c(1, -.5, 0, -1)
names(true.par) <- c("(Intercept)", "S.1", "Z", "S.1:Z")
nsim <- 10
est.bin.para <- matrix(NA, nrow = nsim, ncol = 5)
est.bin.semi <- matrix(NA, nrow = nsim, ncol = 5)
est.bin.pseudo <- matrix(NA, nrow = nsim, ncol = 5)
est.surv.para <- matrix(NA, nrow = nsim, ncol = 5)
est.surv.semi <- matrix(NA, nrow = nsim, ncol = 5)
if(FALSE){
for(i in 1:nsim){
fakedata <- generate_example_data(n = 800)
fakedat.bin <- gen_binary(n = 800)
binary.ps <- psdesign(data = fakedata, Z = Z, Y = Y.obs, S = S.obs, BIP = BIP)
categ.ps <- psdesign(data = fakedat.bin, Z = Z, Y = Y.obs, S = S.obs, BIP = BIP)
surv.ps <- psdesign(data = fakedata, Z = Z, Y = Surv(time.obs, event.obs), S = S.obs, BIP = BIP, tau = 0)
est.bin.para[i, ] <- swoop(binary.ps + integrate_parametric(S.1 ~ BIP) + risk_binary(D = 1000) + ps_estimate())
est.bin.semi[i, ] <- swoop(binary.ps + integrate_semiparametric(S.1 ~ BIP, S.1 ~ 1) + risk_binary(D = 1000) + ps_estimate())
est.bin.pseudo[i, ] <- swoop(categ.ps + integrate_nonparametric(S.1 ~ BIP) + risk_binary(D = 1000) + ps_estimate(method = "pseudo-score"))
est.surv.para[i, ] <- swoop(surv.ps + integrate_parametric(S.1 ~ BIP) + risk_exponential(D = 1000) + ps_estimate())
est.surv.semi[i, ] <- swoop(surv.ps + integrate_semiparametric(S.1 ~ BIP, S.1 ~ 1) + risk_exponential(D = 1000) + ps_estimate())
}
res <- list(bin.para = est.bin.para, bin.semi = est.bin.semi, bin.pseudo = est.bin.pseudo, surv.para = est.surv.para, surv.semi = est.surv.semi)
plotdem <- function(mat){
for(i in 1:(ncol(mat) - 1)){
hist(mat[, i])
abline(v = true.par[i], col = "red", lwd = 2)
}
colMeans(mat[mat[, ncol(mat)] == 1, -ncol(mat)]) - true.par
}
par(mfrow = c(2, 2))
lapply(res, plotdem)
} |
comm.dist <- function(X.gbd, method = "euclidean", diag = FALSE,
upper = FALSE, p = 2, comm = .pbd_env$SPMD.CT$comm,
return.type = c("common", "gbd")){
if(return.type[1] == "common"){
ret <- comm.dist.common(X.gbd, method = method, diag = diag, upper = upper,
p = p, comm = comm)
} else if(return.type[1] == "gbd"){
ret <- comm.dist.gbd(X.gbd, method = method, diag = diag, upper = upper,
p = p, comm = comm)
} else{
comm.stop("The return.type is not found.", comm = comm)
}
ret
}
comm.dist.common <- function(X.gbd, method = "euclidean", diag = FALSE,
upper = FALSE, p = 2, comm = .pbd_env$SPMD.CT$comm){
if(!comm.allcommon.integer(length(dim(X.gbd)), comm = comm)){
comm.stop("Dimension of X.gbd should all equal to 2.", comm = comm)
}
if(!comm.allcommon.integer(ncol(X.gbd), comm = comm)){
comm.stop("X.gbd should have the same
}
COMM.RANK <- spmd.comm.rank(comm)
COMM.SIZE <- spmd.comm.size(comm)
N.gbd <- nrow(X.gbd)
N.allgbd <- spmd.allgather.integer(as.integer(N.gbd), integer(COMM.SIZE),
comm = comm)
N <- sum(N.allgbd)
N.cumsum <- c(1, cumsum(N.allgbd) + 1)
ret <- matrix(-Inf, nrow = N, ncol = N)
tmp <- as.matrix(dist(X.gbd, method = method,
diag = diag, upper = upper, p = p))
ret[N.cumsum[COMM.RANK + 1]:(N.cumsum[COMM.RANK + 2] - 1),
N.cumsum[COMM.RANK + 1]:(N.cumsum[COMM.RANK + 2] - 1)] <- tmp
for(i.rank in 0:(COMM.SIZE - 1)){
if(N.allgbd[i.rank + 1] != 0){
X.other <- bcast(X.gbd, rank.source = i.rank, comm = comm)
if(COMM.RANK < i.rank){
tmp <- as.matrix(dist(rbind(X.gbd, X.other), method = method,
diag = diag, upper = upper, p = p))
ret[N.cumsum[i.rank + 1]:(N.cumsum[i.rank + 2] - 1),
N.cumsum[COMM.RANK + 1]:(N.cumsum[COMM.RANK + 2] - 1)] <-
tmp[(nrow(X.gbd) + 1):nrow(tmp), 1:nrow(X.gbd)]
} else if(COMM.RANK > i.rank){
tmp <- as.matrix(dist(rbind(X.other, X.gbd), method = method,
diag = diag, upper = upper, p = p))
ret[N.cumsum[COMM.RANK + 1]:(N.cumsum[COMM.RANK + 2] - 1),
N.cumsum[i.rank + 1]:(N.cumsum[i.rank + 2] - 1)] <-
tmp[(nrow(X.other) + 1):nrow(tmp), 1:nrow(X.other)]
}
}
}
ret <- allreduce(ret, op = "max")
ret <- as.dist(ret, diag = diag, upper = upper)
ret
}
comm.dist.gbd <- function(X.gbd, method = "euclidean", diag = FALSE,
upper = FALSE, p = 2, comm = .pbd_env$SPMD.CT$comm){
if(!comm.allcommon.integer(length(dim(X.gbd)), comm = comm)){
comm.stop("Dimension of X.gbd should all equal to 2.", comm = comm)
}
if(!comm.allcommon.integer(ncol(X.gbd), comm = comm)){
comm.stop("X.gbd should have the same
}
COMM.RANK <- spmd.comm.rank(comm)
COMM.SIZE <- spmd.comm.size(comm)
N.gbd <- nrow(X.gbd)
N.allgbd <- spmd.allgather.integer(as.integer(N.gbd), integer(COMM.SIZE),
comm = comm)
N <- sum(N.allgbd)
N.cumsum <- c(1, cumsum(N.allgbd) + 1)
if(N.gbd > 0){
ret <- as.matrix(dist(X.gbd, method = method, diag = diag, upper = upper,
p = p))
}
if(COMM.SIZE > 1){
for(i.rank in 1:(COMM.SIZE - 1)){
if(N.allgbd[i.rank + 1] != 0){
X.other <- bcast(X.gbd, rank.source = i.rank, comm = comm)
if(COMM.RANK < i.rank && N.gbd > 0){
tmp <- as.matrix(dist(rbind(X.gbd, X.other), method = method,
diag = diag, upper = upper, p = p))
ret <- rbind(ret, tmp[(nrow(X.gbd) + 1):nrow(tmp), 1:nrow(X.gbd)])
}
}
}
}
if(N.gbd > 0){
ret <- cbind(rep(N.cumsum[COMM.RANK + 1]:N, N.allgbd[COMM.RANK + 1]),
rep(N.cumsum[COMM.RANK + 1]:(N.cumsum[COMM.RANK + 2] - 1),
each = N - N.cumsum[COMM.RANK + 1] + 1),
as.vector(ret))
ret <- ret[ret[, 1] > ret[, 2],]
} else{
ret <- matrix(0, nrow = 0, ncol = 3)
}
dim(ret) <- c(length(ret) / 3, 3)
colnames(ret) <- c("i", "j", "value")
rownames(ret) <- NULL
ret
} |
pprint <- function(x, ...) {
UseMethod("pprint")
}
pprint.matrix <- function(x, rowdots = NULL, coldots = NULL, digits = NULL,
...) {
if (is.null(rowdots)) rowdots <- getOption("pprint.rowdots")
if (is.null(coldots)) coldots <- getOption("pprint.coldots")
if (is.null(digits)) digits <- getOption("digits")
row_labels <- if (is.null(rownames(x))) {
paste0("[", seq_len(nrow(x)), ",]")
} else {
rownames(x)
}
col_labels <- if (is.null(colnames(x))) {
paste0("[,", seq_len(ncol(x)), "]")
} else {
colnames(x)
}
x2 <- rbind(cbind(x[1:rowdots, 1:coldots, drop = FALSE],
x[1:rowdots, ncol(x), drop = FALSE]),
cbind(x[nrow(x), 1:coldots, drop = FALSE],
x[nrow(x), ncol(x), drop = FALSE]))
charx <- if (typeof(x2) == "character") {
x2
} else if (typeof(x2) %in% c("integer", "logical")) {
as.character(x2)
} else {
sprintf(paste0("%.", digits, "f"), x2)
}
dim(charx) <- dim(x2)
if (nrow(x) <= rowdots + 1 && ncol(x) <= coldots + 1) {
res <- x
}
if (nrow(x) > rowdots + 1 && ncol(x) <= coldots + 1) {
res <- rbind(as.matrix(charx[seq_len(rowdots - 1), ]),
rep("...", ncol(charx)),
charx[nrow(charx), ])
row_labels <- add_dots(row_labels, pos = rowdots)
}
if (nrow(x) <= rowdots + 1 && ncol(x) > coldots + 1) {
res <- t(apply(charx, 1, add_dots, pos = coldots))
col_labels <- add_dots(col_labels, pos = coldots)
}
if (nrow(x) > rowdots + 1 && ncol(x) > coldots + 1) {
smallx <- t(apply(charx[seq_len(rowdots - 1), ], 1, add_dots,
pos = coldots))
res <- rbind(smallx,
rep("...", ncol(smallx)),
add_dots(charx[nrow(charx), ], pos = coldots))
row_labels <- add_dots(row_labels, pos = rowdots)
col_labels <- add_dots(col_labels, pos = coldots)
}
cat(desc_mat(x), "\n")
cat("\n")
prmatrix(res, rowlab = row_labels, collab = col_labels, quote = FALSE,
right = TRUE)
invisible(x)
}
pprint.data.frame <- function(x, rowdots = NULL, coldots = NULL, digits = NULL,
...) {
pprint(data.matrix(x), rowdots = rowdots, coldots = coldots, digits = digits,
...)
} |
context("ubio_synonyms")
out <- ubio_synonyms(hierarchiesID = 4091702)
test_that("ubio_synonyms returns the correct value", {
expect_that(dim(out), equals(c(1,9)))
})
test_that("ubio_synonyms returns the correct class", {
expect_that(out, is_a("data.frame"))
}) |
ergm.AME<-function(model,var1,var2=NULL,inter=NULL,at.2=NULL, return.dydx=FALSE, return.at.2=FALSE){
dyad.mat<-edge.prob2(model)[,-c(1)]
dyad.full.mat<-dyad.mat
p<-dyad.mat$probability
start.drops<-ncol(dyad.mat)-5
dyad.mat<-dyad.mat[,-c(start.drops:ncol(dyad.mat))]
if(class(model)=="mtergm"|class(model)=="btergm"){
vc <- stats::vcov(model@ergm)
vc<-vc[!rownames(vc)%in%"offset(edgecov.offsmat)",!colnames(vc)%in%"offset(edgecov.offsmat)"]
}else{
vc <- stats::vcov(model)
}
theta<-btergm::coef(model)
if(class(model)=="mtergm" | class(model)=="btergm"){
if(ergm::is.curved(model@ergm)){
curved.term<-vector(length=length(model$etamap$curved))
for(i in 1:length(model$etamap$curved)){
curved.term[i]<-model$etamap$curved[[i]]$from[2]
}
cbcoef<-cbcoef[-c(curved.term)]
}
}else{
if(ergm::is.curved(model)){
curved.term<-vector(length=length(model$etamap$curved))
for(i in 1:length(model$etamap$curved)){
curved.term[i]<-model$etamap$curved[[i]]$from[2]
}
cbcoef<-cbcoef[-c(curved.term)]
}
}
if(any(names(theta)!=colnames(dyad.mat))){
colnames(dyad.mat)<-names(theta)
}
if(nrow(dyad.mat)>1e06){
message("There are over 1 million dyads in the ERGM sample space. Variance estimates for marginal effects may take a moment to compute.")
}
if(length(theta)>20){
message("There are more than 20 parameters in the model. Variance estimates for marginal effects may take a moment to compute.")
}
if(is.null(at.2)){
at.2<-sort(unique(dyad.mat[,var2]))
}
if(length(at.2)>10){
warning("More than 10 values of at.2 exist for the moderating variable. It may take awhile to compute average marginal effects. Consider specifying fewer values of at.2.")
}
if(is.null(var2)){
AME.fun<-function(theta){
ME.ergm<-sapply(names(theta),function(x)
(p*(1-p)*theta[var1]))
mean(ME.ergm,na.rm = TRUE)}
AME<-AME.fun(theta)
Jac<-numDeriv::jacobian(AME.fun,theta)
variance.ame<-Jac%*%vc%*%t(Jac)
AME.se<-sqrt(variance.ame)
AME.z<-AME/AME.se
P.AME<-2*(stats::pnorm(-abs(AME.z)))
AME<-matrix(c(AME,AME.se,AME.z,P.AME),nrow=1,ncol=4)
colnames(AME)<-c("AME","Delta SE","Z","P")
rownames(AME)<-var1
AME<-signif(AME,digits=5)
if(return.dydx==TRUE){
dydx<-sapply(names(theta),function(x)
(p*(1-p)*theta[var1]))
AME<-list(AME,dydx[,var1])
names(AME)<-c("AME","dydx")
}
return(AME)
}else{
if(!is.na(pmatch("nodematch",inter))){
if(!is.na(pmatch("nodecov",var1)) | !is.na(pmatch("nodeicov",var1)) |
!is.na(pmatch("nodeocov",var1))){
AME.fun<-function(theta){
ME.ergm<-sapply(names(theta),function(x)
(p*(1-p)*theta[var1]))
mean(ME.ergm,na.rm = TRUE)}
AME1<-AME.fun(theta)
Jac<-numDeriv::jacobian(AME.fun,theta)
variance.ame1<-Jac%*%vc%*%t(Jac)
AME1.se<-sqrt(variance.ame1)
AME1.z<-AME1/AME1.se
P.AME1<-2*(stats::pnorm(-abs(AME1.z)))
AME.fun<-function(theta){
ME.ergm<-sapply(names(theta),function(x)
(p*(1-p)*theta[var2]))
mean(ME.ergm,na.rm = TRUE)}
AME2<-AME.fun(theta)
Jac<-numDeriv::jacobian(AME.fun,theta)
variance.ame2<-Jac%*%vc%*%t(Jac)
AME2.se<-sqrt(variance.ame2)
AME2.z<-AME2/AME2.se
P.AME2<-2*(stats::pnorm(-abs(AME2.z)))
AME<-matrix(c(AME1,AME1.se,AME1.z,P.AME1,
AME2,AME2.se,AME2.z,P.AME2),nrow=2,ncol=4,byrow=TRUE)
colnames(AME)<-c("AME","Delta SE","Z","P")
rownames(AME)<-c(var1,var2)
marginal.matrix<-AME
AME.fun<-function(theta){
ME.ergm<-sapply(names(theta),function(x)
(p*(1-p)*theta[inter]))
mean(ME.ergm,na.rm = TRUE)}
AME<-AME.fun(theta)
Jac<-numDeriv::jacobian(AME.fun,theta)
variance.inter<-Jac%*%vc%*%t(Jac)
AME.se<-sqrt(variance.inter)
AME.z<-AME/AME.se
P.AME<-2*(stats::pnorm(-abs(AME.z)))
AME<-matrix(c(AME,AME.se,AME.z,P.AME),nrow=1,ncol=4)
colnames(AME)<-c("AME","Delta SE","Z","P")
rownames(AME)<-inter
message("NOTE: Nodematch is an interaction, but it is not a product of the main effects (e.g., inter!=var1*var2). Returning the simple AME for the interaction. Consider respecifying ERGM using nodefactor for main effects or absdiff instead of nodematch to measure homophily.")
marginal.matrix<-signif(marginal.matrix,digits=5)
AME<-signif(AME,digits=5)
AME<-list(AME,marginal.matrix)
names(AME)<-c("Marginal effect for nodematch","Marginal effects for nodal covariates")
return(AME)
}
}
if(!is.na(pmatch("nodefactor",var1))){
dyad.mat[,var1][which(dyad.mat[,var1]>=2)]<-1
}
if(!is.na(pmatch("nodefactor",var2))){
at.2<-c(0,1)
}
if(var1==var2){
self.int<-TRUE
var2<-paste(var1,".mod")
dyad.mat[,var2]<-dyad.mat[,var1]
}else{
self.int<-FALSE
}
marginal.matrix<-matrix(0,nrow=length(at.2),ncol=5)
colnames(marginal.matrix)<-c("AME","Delta SE","Z","P","N")
rownames(marginal.matrix)<-paste(var2,"==",at.2)
dydx.list<-list()
for(i in 1:nrow(marginal.matrix)){
dyad.submat<-dyad.mat
dyad.submat[,var2]<-at.2[i]
if(!is.na(pmatch("absdiff",inter))){
dyad.submat[,inter]<-abs(dyad.submat[,var1]-dyad.submat[,var2])
if(i ==1){message(paste("Note that marginal effects for absolute differences are computed holding",var1,"at its mean. The mean for",var1,"is", mean(dyad.mat[,var1])))}
if(self.int==TRUE){
dyad.submat<-dyad.submat[,!colnames(dyad.submat)%in%var2]
}
p<-1/(1+exp(-(apply(dyad.submat,1,function(x) t(x)%*%theta))))
at.diffs<-abs(at.2[i]-mean(dyad.mat[,var1]))
AME.fun<-function(theta){
ME.ergm<-sapply(names(theta),function(x)
(p*(1-p)*(theta[var1]+(theta[inter]*at.diffs))))
mean(ME.ergm,na.rm = TRUE)}
dydx.list[[i]]<-sapply(names(theta),function(x)
(p*(1-p)*(theta[var1]+(theta[inter]*at.diffs))))
}else{
dyad.submat[,inter]<-dyad.submat[,var1]*dyad.submat[,var2]
if(self.int==TRUE){
dyad.submat<-dyad.submat[,!colnames(dyad.submat)%in%var2]
}
p<-1/(1+exp(-(apply(dyad.submat,1,function(x) t(x)%*%theta))))
AME.fun<-function(theta){
ME.ergm<-sapply(names(theta),function(x)
(p*(1-p)*(theta[var1]+(theta[inter]*at.2[i]))))
mean(ME.ergm,na.rm = TRUE)}
dydx.list[[i]]<-sapply(names(theta),function(x)
(p*(1-p)*(theta[var1]+(theta[inter]*at.2[i]))))
}
AME<-AME.fun(theta)
Jac<-numDeriv::jacobian(AME.fun,theta)
marginal.matrix[i,1]<-AME
if(i==1){
Jac1<-matrix(Jac)
}else{
Jac1<-cbind(Jac1,matrix(Jac))}
}
variance.ame<-t(Jac1)%*%vc%*%Jac1
AME.se<-sqrt(diag(variance.ame))
marginal.matrix[,2]<-AME.se
marginal.matrix[,3]<-marginal.matrix[,1]/AME.se
marginal.matrix[,4]<-2*(stats::pnorm(-abs(marginal.matrix[,3])))
marginal.matrix[,5]<-length(p)
if(length(at.2)==1){
AME<-t(as.matrix(marginal.matrix[,-c(5)]))
rownames(AME)<-rownames(marginal.matrix)
if(return.dydx==TRUE){
AME<-list(AME,dydx.list)
names(AME)<-c("Average Marginal effects","Marginal effects")
}
if(return.at.2==TRUE){
AME<-list(main.results=AME,
at.2=at.2)
}
return(AME)
}
second.diffs.mat<-as.matrix(diff(marginal.matrix)[,1:4])
if(length(at.2)==2){
second.diffs.mat<-t(second.diffs.mat)
}
for(j in 1:nrow(second.diffs.mat)){
k<-j+1
diff.se<-sqrt((marginal.matrix[j,2]^2)+(marginal.matrix[k,2]^2)-2*variance.ame[j,k])
df<-marginal.matrix[j,5]-length(theta)
z.ADC<-(second.diffs.mat[j,1])/diff.se
P.ADC<-2*stats::pnorm(-abs(z.ADC))
second.diffs.mat[j,2]<-diff.se
second.diffs.mat[j,3]<-z.ADC
second.diffs.mat[j,4]<-P.ADC
}
colnames(second.diffs.mat)<-c("Second. diff.","SE","Wald Z","P")
rownames(second.diffs.mat)<-paste(at.2[-c(length(at.2))],"to",at.2[-c(1)])
marginal.matrix<-signif(marginal.matrix,digits=5)
second.diffs.mat<-signif(second.diffs.mat,digits=5)
if(length(at.2)==2){
if(return.dydx==FALSE){
ADC<-list(second.diffs.mat,marginal.matrix[,-c(ncol(marginal.matrix))])
names(ADC)<-c("Second differences","Average Marginal effects")}else{
ADC<-list(second.diffs.mat,marginal.matrix[,-c(ncol(marginal.matrix))],dydx.list)
names(ADC)<-c("Second differences","Average Marginal effects","Marginal effects")
}
if(return.at.2==TRUE){
ADC<-list(ADC,at.2)
names(ADC)<-c("main.results","at.2")
}
return(ADC)
}else{
summary.output<-matrix(c(mean(second.diffs.mat[,1]),mean(abs(second.diffs.mat[,3])),NA),nrow=1,ncol=3)
colnames(summary.output)<-c("Mean Second diff.","Mean |Z|", "P")
summary.output[1,3]<-2*stats::pnorm(abs(summary.output[1,2]),lower.tail = FALSE)
summary.output<-signif(summary.output,digits=5)
if(return.dydx==FALSE){
ADC<-list(summary.output,second.diffs.mat,marginal.matrix[,-c(ncol(marginal.matrix))])
names(ADC)<-c("Aggregate output","Second differences","Average Marginal effects")}else{
ADC<-list(summary.output,second.diffs.mat,marginal.matrix[,-c(ncol(marginal.matrix))],dydx.list)
names(ADC)<-c("Aggregate output","Second differences","Average Marginal effects","Marginal effects")
}
if(return.at.2==TRUE){
ADC<-list(ADC,at.2)
names(ADC)<-c("main.results","at.2")
}
return(ADC)
}
}
} |
apportion_wedge <- function(angle_total, angle_well) {
frac_depletion <- c((1 - (angle_well / angle_total)), angle_well / angle_total)
return(frac_depletion)
} |
ryt_get_channel_activities <- function(
fields = c('contentDetails',
'id',
'snippet')
) {
cli_alert_info('Compose params')
q_params <- list(
mine = TRUE,
part = paste0(fields, collapse = ","),
maxResults = 50
)
result <- list()
cli_alert_info('Send query')
while (!is.null(q_params$pageToken)|!exists('resp', inherits = FALSE)) {
out <- request_build(
method = "GET",
params = q_params,
token = ryt_token(),
path = 'youtube/v3/activities',
base_url = 'https://www.googleapis.com/'
)
ans <- request_retry(
out,
encode = 'json'
)
resp <- response_process(ans)
result <- append(result, list(resp$items))
q_params$pageToken <- resp$nextPageToken
}
cli_alert_info('Parse result')
result <- tibble(items = result) %>%
unnest_longer(.data$items) %>%
unnest_wider(.data$items)
if ( 'snippet' %in% fields ) result <- unnest_wider(result, .data$snippet)
if ( 'contentDetails' %in% fields ) result <- unnest_wider(result, .data$contentDetails)
result <- rename_with(result, to_snake_case)
cli_alert_success(str_glue('Success, loading {nrow(result)} rows.'))
return(result)
} |
x <- 1:5 + 0.5 + .Machine$integer.max
expect_equal(or3s(x > 2147483649.5), x > 2147483649.5)
expect_equal(sum_or3s(x > 2147483649.5), sum(x > 2147483649.5))
expect_equal(and3s(x > 2147483649.5), x > 2147483649.5)
expect_equal(sum_and3s(x > 2147483649.5), sum(x > 2147483649.5))
A <-
c(-945028649L, -705457251L, 807204080L, 1708708214L, -885957403L,
1862209884L, 1740762002L, 1546012157L, -1233491410L, 1256036667L,
1009745233L, -815497191L, 137228285L, 2012907335L, -314954938L,
-1234120580L, 2138414482L, 2089828880L, -1494606089L, 1669541061L,
-1635694586L, 913293496L, 657757461L)
A <- rep_len(A, 101)
B <- c(-705457251L, 1:1000)
D <- rep(TRUE, length(B))
E <- rep(TRUE, length(B))
bor3 <- function(x, y, z, ...) if (missing(..1)) ((x | y) | z) else bor3(x | y, z, ...)
expect_equal(or3s(B %in% A, D, E),
bor3(B %in% A, D, E))
expect_equal(or3s(D, B %in% A, D, E),
bor3(D, B %in% A, D, E))
expect_equal(or3s(D, E, B %in% A, D, E),
bor3(D, E, B %in% A, D, E))
expect_equal(or3s(D, E, E, B %in% A, D, E),
bor3(D, E, E, B %in% A, D, E))
expect_equal(or3s(D, E, E, B %in% A, !D, !E),
bor3(D, E, E, B %in% A, !D, !E))
z <- function() or3s(D, E, B %in% A)
expect_equal(z(), bor3(D, E, B %in% A))
A <- c(FALSE, TRUE, TRUE)
expect_equal(or3s(A, A, !A), A | A | !A)
expect_equal(or3s(A, !A, !A), A | !A | !A)
library(data.table)
library(hutils)
samp <- function(..., loud = FALSE) hutils::samp(..., loud = loud)
bor3 <- function(exprA, exprB, exprC) {
if (missing(exprC) && missing(exprB)) {
return(exprA)
}
if (missing(exprC)) {
return(exprA | exprB)
}
if (missing(exprB)) {
return(exprA | exprC)
}
(exprA | exprB) | exprC
}
library(magrittr)
gen_one_expr <- function(lhs = "", op = "", val = 1L, In_As_Between = FALSE) {
if (op == "") {
return(paste0("logi_", lhs))
}
if (op == "!") {
return(paste0("!", paste0("logi_", lhs)))
}
switch(op,
"%between%" = paste(lhs, "%between% c(-1L, 1L)"),
"%in%" = paste(lhs, "%in%",
if (In_As_Between) {
"1:4"
} else {
"c(4L, -3L, 2L, 7L, 8L)"
}),
paste(lhs, op, val))
}
DT <-
CJ(Op1 = c("", "!", "!=", "==", ">=", "<=", ">", "<", "%in%", "%between%"),
Op2 = c("", "!", "!=", "==", ">=", "<=", ">", "<", "%in%", "%between%"),
Op3 = c("", "!", "!=", "==", ">=", "<=", ">", "<", "%in%", "%between%"),
In_As_Between = c(FALSE, TRUE),
e2 = c(FALSE, TRUE),
e3 = c(FALSE, TRUE),
val = c("0L", "1L", "9L")) %>%
.[implies(In_As_Between, Op1 == "%in%" | Op2 == "%in%" | Op3 == "%in%")]
i2letters <- function(I) {
out <- character(length(I))
M <- matrix(0L, byrow = FALSE, ncol = ceiling(log(length(I), 26L)), nrow = length(I))
M[, 1] <- rep_len(1:26, length(I))
for (j in 2:ncol(M)) {
eachj <- 26 ^ (j - 1L)
if (eachj > length(I)) {
break
}
M[, j] <- rep_len(rep(0:25, each = eachj), length(I))
}
M2 <- matrix("", ncol = ncol(M), nrow = nrow(M))
for (j in 1:ncol(M2)) {
M2[, ncol(M2) - j + 1] <- hutils::if_else(M[, j] > 0L, c("", letters)[M[, j] + 1L], "")
}
for (i in seq_along(out)) {
out[i] <- paste0(M2[i, ], collapse = "")
}
out
}
DT[, ii := .I]
DT[, lhs1 := i2letters(ii)]
DT[lhs1 %in% c("for", "if", "else", "repeat", "in", "next", "break"), lhs1 := toupper(lhs1)]
DT[, lhs2 := samp(letters, size = .N)]
DT[, lhs3 := samp(letters, size = .N)]
DT[, expr_one := gen_one_expr(lhs1, Op1, val = val, In_As_Between = In_As_Between), by = "ii"]
DT[, expr_two := gen_one_expr(lhs2, Op2, val = val, In_As_Between = In_As_Between), by = "ii"]
DT[, expr_three := gen_one_expr(lhs3, Op3, val = val, In_As_Between = In_As_Between), by = "ii"]
DT[, the_expr := paste0("expect_equal(",
paste0("or3s(",
expr_one, ", ",
if_else(e2, expr_two, ""), ", ",
if_else(e3, expr_three, ""), ")"),
",\n",
paste0("bor3(",
expr_one, ", ",
if_else(e2, expr_two, ""), ", ",
if_else(e3, expr_three, ""), ")"),
")")]
generate_int <- function() rep_len(samp(-15:101, size = 99), 231)
generate_lgl <- function() rep_len(hutils::samp(c(TRUE, FALSE), size = 20, loud = FALSE), 231)
for (tmp__0 in unique(c(DT[["lhs1"]], DT[["lhs2"]], DT[["lhs3"]], letters))) {
assign(paste0("logi_", tmp__0), value = generate_lgl())
assign(tmp__0, value = generate_int())
}
expect_equal(or3s(logi_a, , ),
bor3(logi_a, , ))
expect_equal(or3s(logi_b, , ),
bor3(logi_b, , ))
expect_equal(or3s(logi_c, , ),
bor3(logi_c, , ))
expect_equal(or3s(logi_d, , logi_d),
bor3(logi_d, , logi_d))
expect_equal(or3s(logi_e, , logi_p),
bor3(logi_e, , logi_p))
expect_equal(or3s(logi_f, , logi_x),
bor3(logi_f, , logi_x))
expect_equal(or3s(logi_g, logi_b, ),
bor3(logi_g, logi_b, ))
expect_equal(or3s(logi_h, logi_g, ),
bor3(logi_h, logi_g, ))
expect_equal(or3s(logi_i, logi_p, ),
bor3(logi_i, logi_p, ))
expect_equal(or3s(logi_j, logi_s, logi_d),
bor3(logi_j, logi_s, logi_d))
expect_equal(or3s(logi_k, logi_q, logi_x),
bor3(logi_k, logi_q, logi_x))
expect_equal(or3s(logi_l, logi_a, logi_z),
bor3(logi_l, logi_a, logi_z))
expect_equal(or3s(logi_m, , ),
bor3(logi_m, , ))
expect_equal(or3s(logi_n, , ),
bor3(logi_n, , ))
expect_equal(or3s(logi_o, , ),
bor3(logi_o, , ))
expect_equal(or3s(logi_p, , !logi_g),
bor3(logi_p, , !logi_g))
expect_equal(or3s(logi_q, , !logi_p),
bor3(logi_q, , !logi_p))
expect_equal(or3s(logi_r, , !logi_m),
bor3(logi_r, , !logi_m))
expect_equal(or3s(logi_s, logi_v, ),
bor3(logi_s, logi_v, ))
expect_equal(or3s(logi_t, logi_z, ),
bor3(logi_t, logi_z, ))
expect_equal(or3s(logi_u, logi_s, ),
bor3(logi_u, logi_s, ))
expect_equal(or3s(logi_v, logi_y, !logi_v),
bor3(logi_v, logi_y, !logi_v))
expect_equal(or3s(logi_w, logi_m, !logi_a),
bor3(logi_w, logi_m, !logi_a))
expect_equal(or3s(logi_x, logi_f, !logi_w),
bor3(logi_x, logi_f, !logi_w))
expect_equal(or3s(logi_y, , ),
bor3(logi_y, , ))
expect_equal(or3s(logi_z, , ),
bor3(logi_z, , ))
expect_equal(or3s(logi_aa, , ),
bor3(logi_aa, , ))
expect_equal(or3s(logi_ab, , n != 0L),
bor3(logi_ab, , n != 0L))
expect_equal(or3s(logi_ac, , f != 1L),
bor3(logi_ac, , f != 1L))
expect_equal(or3s(logi_ad, , d != 9L),
bor3(logi_ad, , d != 9L))
expect_equal(or3s(logi_ae, logi_x, ),
bor3(logi_ae, logi_x, ))
expect_equal(or3s(logi_af, logi_x, ),
bor3(logi_af, logi_x, ))
expect_equal(or3s(logi_ag, logi_v, ),
bor3(logi_ag, logi_v, ))
expect_equal(or3s(logi_ah, logi_y, j != 0L),
bor3(logi_ah, logi_y, j != 0L))
expect_equal(or3s(logi_ai, logi_i, j != 1L),
bor3(logi_ai, logi_i, j != 1L))
expect_equal(or3s(logi_aj, logi_p, o != 9L),
bor3(logi_aj, logi_p, o != 9L))
expect_equal(or3s(logi_ak, , ),
bor3(logi_ak, , ))
expect_equal(or3s(logi_al, , ),
bor3(logi_al, , ))
expect_equal(or3s(logi_am, , ),
bor3(logi_am, , ))
expect_equal(or3s(logi_an, , j %between% c(-1L, 1L)),
bor3(logi_an, , j %between% c(-1L, 1L)))
expect_equal(or3s(logi_ao, , d %between% c(-1L, 1L)),
bor3(logi_ao, , d %between% c(-1L, 1L)))
expect_equal(or3s(logi_ap, , n %between% c(-1L, 1L)),
bor3(logi_ap, , n %between% c(-1L, 1L)))
expect_equal(or3s(logi_aq, logi_t, ),
bor3(logi_aq, logi_t, ))
expect_equal(or3s(logi_ar, logi_q, ),
bor3(logi_ar, logi_q, ))
expect_equal(or3s(logi_as, logi_z, ),
bor3(logi_as, logi_z, ))
expect_equal(or3s(logi_at, logi_h, l %between% c(-1L, 1L)),
bor3(logi_at, logi_h, l %between% c(-1L, 1L)))
expect_equal(or3s(logi_au, logi_n, j %between% c(-1L, 1L)),
bor3(logi_au, logi_n, j %between% c(-1L, 1L)))
expect_equal(or3s(logi_av, logi_e, v %between% c(-1L, 1L)),
bor3(logi_av, logi_e, v %between% c(-1L, 1L)))
expect_equal(or3s(logi_aw, , ),
bor3(logi_aw, , ))
expect_equal(or3s(logi_ax, , ),
bor3(logi_ax, , ))
expect_equal(or3s(logi_ay, , ),
bor3(logi_ay, , ))
expect_equal(or3s(logi_az, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_az, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ba, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ba, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bb, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bb, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bc, logi_t, ),
bor3(logi_bc, logi_t, ))
expect_equal(or3s(logi_bd, logi_n, ),
bor3(logi_bd, logi_n, ))
expect_equal(or3s(logi_be, logi_s, ),
bor3(logi_be, logi_s, ))
expect_equal(or3s(logi_bf, logi_x, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bf, logi_x, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bg, logi_e, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bg, logi_e, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bh, logi_n, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bh, logi_n, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bi, , ),
bor3(logi_bi, , ))
expect_equal(or3s(logi_bj, , ),
bor3(logi_bj, , ))
expect_equal(or3s(logi_bk, , ),
bor3(logi_bk, , ))
expect_equal(or3s(logi_bl, , q %in% 1:4),
bor3(logi_bl, , q %in% 1:4))
expect_equal(or3s(logi_bm, , u %in% 1:4),
bor3(logi_bm, , u %in% 1:4))
expect_equal(or3s(logi_bn, , r %in% 1:4),
bor3(logi_bn, , r %in% 1:4))
expect_equal(or3s(logi_bo, logi_q, ),
bor3(logi_bo, logi_q, ))
expect_equal(or3s(logi_bp, logi_i, ),
bor3(logi_bp, logi_i, ))
expect_equal(or3s(logi_bq, logi_p, ),
bor3(logi_bq, logi_p, ))
expect_equal(or3s(logi_br, logi_l, b %in% 1:4),
bor3(logi_br, logi_l, b %in% 1:4))
expect_equal(or3s(logi_bs, logi_b, f %in% 1:4),
bor3(logi_bs, logi_b, f %in% 1:4))
expect_equal(or3s(logi_bt, logi_l, j %in% 1:4),
bor3(logi_bt, logi_l, j %in% 1:4))
expect_equal(or3s(logi_bu, , ),
bor3(logi_bu, , ))
expect_equal(or3s(logi_bv, , ),
bor3(logi_bv, , ))
expect_equal(or3s(logi_bw, , ),
bor3(logi_bw, , ))
expect_equal(or3s(logi_bx, , i < 0L),
bor3(logi_bx, , i < 0L))
expect_equal(or3s(logi_by, , n < 1L),
bor3(logi_by, , n < 1L))
expect_equal(or3s(logi_bz, , k < 9L),
bor3(logi_bz, , k < 9L))
expect_equal(or3s(logi_ca, logi_n, ),
bor3(logi_ca, logi_n, ))
expect_equal(or3s(logi_cb, logi_e, ),
bor3(logi_cb, logi_e, ))
expect_equal(or3s(logi_cc, logi_x, ),
bor3(logi_cc, logi_x, ))
expect_equal(or3s(logi_cd, logi_s, f < 0L),
bor3(logi_cd, logi_s, f < 0L))
expect_equal(or3s(logi_ce, logi_q, h < 1L),
bor3(logi_ce, logi_q, h < 1L))
expect_equal(or3s(logi_cf, logi_r, p < 9L),
bor3(logi_cf, logi_r, p < 9L))
expect_equal(or3s(logi_cg, , ),
bor3(logi_cg, , ))
expect_equal(or3s(logi_ch, , ),
bor3(logi_ch, , ))
expect_equal(or3s(logi_ci, , ),
bor3(logi_ci, , ))
expect_equal(or3s(logi_cj, , k <= 0L),
bor3(logi_cj, , k <= 0L))
expect_equal(or3s(logi_ck, , a <= 1L),
bor3(logi_ck, , a <= 1L))
expect_equal(or3s(logi_cl, , r <= 9L),
bor3(logi_cl, , r <= 9L))
expect_equal(or3s(logi_cm, logi_s, ),
bor3(logi_cm, logi_s, ))
expect_equal(or3s(logi_cn, logi_j, ),
bor3(logi_cn, logi_j, ))
expect_equal(or3s(logi_co, logi_t, ),
bor3(logi_co, logi_t, ))
expect_equal(or3s(logi_cp, logi_x, t <= 0L),
bor3(logi_cp, logi_x, t <= 0L))
expect_equal(or3s(logi_cq, logi_c, v <= 1L),
bor3(logi_cq, logi_c, v <= 1L))
expect_equal(or3s(logi_cr, logi_v, q <= 9L),
bor3(logi_cr, logi_v, q <= 9L))
expect_equal(or3s(logi_cs, , ),
bor3(logi_cs, , ))
expect_equal(or3s(logi_ct, , ),
bor3(logi_ct, , ))
expect_equal(or3s(logi_cu, , ),
bor3(logi_cu, , ))
expect_equal(or3s(logi_cv, , g == 0L),
bor3(logi_cv, , g == 0L))
expect_equal(or3s(logi_cw, , a == 1L),
bor3(logi_cw, , a == 1L))
expect_equal(or3s(logi_cx, , d == 9L),
bor3(logi_cx, , d == 9L))
expect_equal(or3s(logi_cy, logi_i, ),
bor3(logi_cy, logi_i, ))
expect_equal(or3s(logi_cz, logi_g, ),
bor3(logi_cz, logi_g, ))
expect_equal(or3s(logi_da, logi_k, ),
bor3(logi_da, logi_k, ))
expect_equal(or3s(logi_db, logi_t, b == 0L),
bor3(logi_db, logi_t, b == 0L))
expect_equal(or3s(logi_dc, logi_o, l == 1L),
bor3(logi_dc, logi_o, l == 1L))
expect_equal(or3s(logi_dd, logi_m, w == 9L),
bor3(logi_dd, logi_m, w == 9L))
expect_equal(or3s(logi_de, , ),
bor3(logi_de, , ))
expect_equal(or3s(logi_df, , ),
bor3(logi_df, , ))
expect_equal(or3s(logi_dg, , ),
bor3(logi_dg, , ))
expect_equal(or3s(logi_dh, , u > 0L),
bor3(logi_dh, , u > 0L))
expect_equal(or3s(logi_di, , p > 1L),
bor3(logi_di, , p > 1L))
expect_equal(or3s(logi_dj, , y > 9L),
bor3(logi_dj, , y > 9L))
expect_equal(or3s(logi_dk, logi_x, ),
bor3(logi_dk, logi_x, ))
expect_equal(or3s(logi_dl, logi_q, ),
bor3(logi_dl, logi_q, ))
expect_equal(or3s(logi_dm, logi_k, ),
bor3(logi_dm, logi_k, ))
expect_equal(or3s(logi_dn, logi_b, o > 0L),
bor3(logi_dn, logi_b, o > 0L))
expect_equal(or3s(logi_do, logi_y, g > 1L),
bor3(logi_do, logi_y, g > 1L))
expect_equal(or3s(logi_dp, logi_t, k > 9L),
bor3(logi_dp, logi_t, k > 9L))
expect_equal(or3s(logi_dq, , ),
bor3(logi_dq, , ))
expect_equal(or3s(logi_dr, , ),
bor3(logi_dr, , ))
expect_equal(or3s(logi_ds, , ),
bor3(logi_ds, , ))
expect_equal(or3s(logi_dt, , d >= 0L),
bor3(logi_dt, , d >= 0L))
expect_equal(or3s(logi_du, , k >= 1L),
bor3(logi_du, , k >= 1L))
expect_equal(or3s(logi_dv, , k >= 9L),
bor3(logi_dv, , k >= 9L))
expect_equal(or3s(logi_dw, logi_g, ),
bor3(logi_dw, logi_g, ))
expect_equal(or3s(logi_dx, logi_r, ),
bor3(logi_dx, logi_r, ))
expect_equal(or3s(logi_dy, logi_s, ),
bor3(logi_dy, logi_s, ))
expect_equal(or3s(logi_dz, logi_z, x >= 0L),
bor3(logi_dz, logi_z, x >= 0L))
expect_equal(or3s(logi_ea, logi_g, t >= 1L),
bor3(logi_ea, logi_g, t >= 1L))
expect_equal(or3s(logi_eb, logi_c, p >= 9L),
bor3(logi_eb, logi_c, p >= 9L))
expect_equal(or3s(logi_ec, , ),
bor3(logi_ec, , ))
expect_equal(or3s(logi_ed, , ),
bor3(logi_ed, , ))
expect_equal(or3s(logi_ee, , ),
bor3(logi_ee, , ))
expect_equal(or3s(logi_ef, , logi_n),
bor3(logi_ef, , logi_n))
expect_equal(or3s(logi_eg, , logi_e),
bor3(logi_eg, , logi_e))
expect_equal(or3s(logi_eh, , logi_k),
bor3(logi_eh, , logi_k))
expect_equal(or3s(logi_ei, !logi_s, ),
bor3(logi_ei, !logi_s, ))
expect_equal(or3s(logi_ej, !logi_j, ),
bor3(logi_ej, !logi_j, ))
expect_equal(or3s(logi_ek, !logi_m, ),
bor3(logi_ek, !logi_m, ))
expect_equal(or3s(logi_el, !logi_p, logi_k),
bor3(logi_el, !logi_p, logi_k))
expect_equal(or3s(logi_em, !logi_e, logi_o),
bor3(logi_em, !logi_e, logi_o))
expect_equal(or3s(logi_en, !logi_x, logi_a),
bor3(logi_en, !logi_x, logi_a))
expect_equal(or3s(logi_eo, , ),
bor3(logi_eo, , ))
expect_equal(or3s(logi_ep, , ),
bor3(logi_ep, , ))
expect_equal(or3s(logi_eq, , ),
bor3(logi_eq, , ))
expect_equal(or3s(logi_er, , !logi_n),
bor3(logi_er, , !logi_n))
expect_equal(or3s(logi_es, , !logi_d),
bor3(logi_es, , !logi_d))
expect_equal(or3s(logi_et, , !logi_y),
bor3(logi_et, , !logi_y))
expect_equal(or3s(logi_eu, !logi_f, ),
bor3(logi_eu, !logi_f, ))
expect_equal(or3s(logi_ev, !logi_l, ),
bor3(logi_ev, !logi_l, ))
expect_equal(or3s(logi_ew, !logi_r, ),
bor3(logi_ew, !logi_r, ))
expect_equal(or3s(logi_ex, !logi_d, !logi_m),
bor3(logi_ex, !logi_d, !logi_m))
expect_equal(or3s(logi_ey, !logi_o, !logi_m),
bor3(logi_ey, !logi_o, !logi_m))
expect_equal(or3s(logi_ez, !logi_f, !logi_j),
bor3(logi_ez, !logi_f, !logi_j))
expect_equal(or3s(logi_fa, , ),
bor3(logi_fa, , ))
expect_equal(or3s(logi_fb, , ),
bor3(logi_fb, , ))
expect_equal(or3s(logi_fc, , ),
bor3(logi_fc, , ))
expect_equal(or3s(logi_fd, , y != 0L),
bor3(logi_fd, , y != 0L))
expect_equal(or3s(logi_fe, , h != 1L),
bor3(logi_fe, , h != 1L))
expect_equal(or3s(logi_ff, , t != 9L),
bor3(logi_ff, , t != 9L))
expect_equal(or3s(logi_fg, !logi_m, ),
bor3(logi_fg, !logi_m, ))
expect_equal(or3s(logi_fh, !logi_z, ),
bor3(logi_fh, !logi_z, ))
expect_equal(or3s(logi_fi, !logi_s, ),
bor3(logi_fi, !logi_s, ))
expect_equal(or3s(logi_fj, !logi_m, t != 0L),
bor3(logi_fj, !logi_m, t != 0L))
expect_equal(or3s(logi_fk, !logi_t, l != 1L),
bor3(logi_fk, !logi_t, l != 1L))
expect_equal(or3s(logi_fl, !logi_l, l != 9L),
bor3(logi_fl, !logi_l, l != 9L))
expect_equal(or3s(logi_fm, , ),
bor3(logi_fm, , ))
expect_equal(or3s(logi_fn, , ),
bor3(logi_fn, , ))
expect_equal(or3s(logi_fo, , ),
bor3(logi_fo, , ))
expect_equal(or3s(logi_fp, , n %between% c(-1L, 1L)),
bor3(logi_fp, , n %between% c(-1L, 1L)))
expect_equal(or3s(logi_fq, , x %between% c(-1L, 1L)),
bor3(logi_fq, , x %between% c(-1L, 1L)))
expect_equal(or3s(logi_fr, , r %between% c(-1L, 1L)),
bor3(logi_fr, , r %between% c(-1L, 1L)))
expect_equal(or3s(logi_fs, !logi_l, ),
bor3(logi_fs, !logi_l, ))
expect_equal(or3s(logi_ft, !logi_n, ),
bor3(logi_ft, !logi_n, ))
expect_equal(or3s(logi_fu, !logi_p, ),
bor3(logi_fu, !logi_p, ))
expect_equal(or3s(logi_fv, !logi_f, s %between% c(-1L, 1L)),
bor3(logi_fv, !logi_f, s %between% c(-1L, 1L)))
expect_equal(or3s(logi_fw, !logi_c, t %between% c(-1L, 1L)),
bor3(logi_fw, !logi_c, t %between% c(-1L, 1L)))
expect_equal(or3s(logi_fx, !logi_x, a %between% c(-1L, 1L)),
bor3(logi_fx, !logi_x, a %between% c(-1L, 1L)))
expect_equal(or3s(logi_fy, , ),
bor3(logi_fy, , ))
expect_equal(or3s(logi_fz, , ),
bor3(logi_fz, , ))
expect_equal(or3s(logi_ga, , ),
bor3(logi_ga, , ))
expect_equal(or3s(logi_gb, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_gb, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_gc, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_gc, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_gd, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_gd, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ge, !logi_z, ),
bor3(logi_ge, !logi_z, ))
expect_equal(or3s(logi_gf, !logi_r, ),
bor3(logi_gf, !logi_r, ))
expect_equal(or3s(logi_gg, !logi_b, ),
bor3(logi_gg, !logi_b, ))
expect_equal(or3s(logi_gh, !logi_v, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_gh, !logi_v, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_gi, !logi_r, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_gi, !logi_r, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_gj, !logi_y, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_gj, !logi_y, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_gk, , ),
bor3(logi_gk, , ))
expect_equal(or3s(logi_gl, , ),
bor3(logi_gl, , ))
expect_equal(or3s(logi_gm, , ),
bor3(logi_gm, , ))
expect_equal(or3s(logi_gn, , h %in% 1:4),
bor3(logi_gn, , h %in% 1:4))
expect_equal(or3s(logi_go, , a %in% 1:4),
bor3(logi_go, , a %in% 1:4))
expect_equal(or3s(logi_gp, , q %in% 1:4),
bor3(logi_gp, , q %in% 1:4))
expect_equal(or3s(logi_gq, !logi_q, ),
bor3(logi_gq, !logi_q, ))
expect_equal(or3s(logi_gr, !logi_x, ),
bor3(logi_gr, !logi_x, ))
expect_equal(or3s(logi_gs, !logi_b, ),
bor3(logi_gs, !logi_b, ))
expect_equal(or3s(logi_gt, !logi_z, a %in% 1:4),
bor3(logi_gt, !logi_z, a %in% 1:4))
expect_equal(or3s(logi_gu, !logi_k, z %in% 1:4),
bor3(logi_gu, !logi_k, z %in% 1:4))
expect_equal(or3s(logi_gv, !logi_e, w %in% 1:4),
bor3(logi_gv, !logi_e, w %in% 1:4))
expect_equal(or3s(logi_gw, , ),
bor3(logi_gw, , ))
expect_equal(or3s(logi_gx, , ),
bor3(logi_gx, , ))
expect_equal(or3s(logi_gy, , ),
bor3(logi_gy, , ))
expect_equal(or3s(logi_gz, , i < 0L),
bor3(logi_gz, , i < 0L))
expect_equal(or3s(logi_ha, , x < 1L),
bor3(logi_ha, , x < 1L))
expect_equal(or3s(logi_hb, , j < 9L),
bor3(logi_hb, , j < 9L))
expect_equal(or3s(logi_hc, !logi_r, ),
bor3(logi_hc, !logi_r, ))
expect_equal(or3s(logi_hd, !logi_v, ),
bor3(logi_hd, !logi_v, ))
expect_equal(or3s(logi_he, !logi_w, ),
bor3(logi_he, !logi_w, ))
expect_equal(or3s(logi_hf, !logi_t, t < 0L),
bor3(logi_hf, !logi_t, t < 0L))
expect_equal(or3s(logi_hg, !logi_t, c < 1L),
bor3(logi_hg, !logi_t, c < 1L))
expect_equal(or3s(logi_hh, !logi_f, u < 9L),
bor3(logi_hh, !logi_f, u < 9L))
expect_equal(or3s(logi_hi, , ),
bor3(logi_hi, , ))
expect_equal(or3s(logi_hj, , ),
bor3(logi_hj, , ))
expect_equal(or3s(logi_hk, , ),
bor3(logi_hk, , ))
expect_equal(or3s(logi_hl, , y <= 0L),
bor3(logi_hl, , y <= 0L))
expect_equal(or3s(logi_hm, , m <= 1L),
bor3(logi_hm, , m <= 1L))
expect_equal(or3s(logi_hn, , e <= 9L),
bor3(logi_hn, , e <= 9L))
expect_equal(or3s(logi_ho, !logi_r, ),
bor3(logi_ho, !logi_r, ))
expect_equal(or3s(logi_hp, !logi_g, ),
bor3(logi_hp, !logi_g, ))
expect_equal(or3s(logi_hq, !logi_t, ),
bor3(logi_hq, !logi_t, ))
expect_equal(or3s(logi_hr, !logi_e, d <= 0L),
bor3(logi_hr, !logi_e, d <= 0L))
expect_equal(or3s(logi_hs, !logi_y, d <= 1L),
bor3(logi_hs, !logi_y, d <= 1L))
expect_equal(or3s(logi_ht, !logi_p, m <= 9L),
bor3(logi_ht, !logi_p, m <= 9L))
expect_equal(or3s(logi_hu, , ),
bor3(logi_hu, , ))
expect_equal(or3s(logi_hv, , ),
bor3(logi_hv, , ))
expect_equal(or3s(logi_hw, , ),
bor3(logi_hw, , ))
expect_equal(or3s(logi_hx, , m == 0L),
bor3(logi_hx, , m == 0L))
expect_equal(or3s(logi_hy, , x == 1L),
bor3(logi_hy, , x == 1L))
expect_equal(or3s(logi_hz, , n == 9L),
bor3(logi_hz, , n == 9L))
expect_equal(or3s(logi_ia, !logi_y, ),
bor3(logi_ia, !logi_y, ))
expect_equal(or3s(logi_ib, !logi_h, ),
bor3(logi_ib, !logi_h, ))
expect_equal(or3s(logi_ic, !logi_c, ),
bor3(logi_ic, !logi_c, ))
expect_equal(or3s(logi_id, !logi_t, f == 0L),
bor3(logi_id, !logi_t, f == 0L))
expect_equal(or3s(logi_ie, !logi_e, w == 1L),
bor3(logi_ie, !logi_e, w == 1L))
expect_equal(or3s(logi_IF, !logi_y, p == 9L),
bor3(logi_IF, !logi_y, p == 9L))
expect_equal(or3s(logi_ig, , ),
bor3(logi_ig, , ))
expect_equal(or3s(logi_ih, , ),
bor3(logi_ih, , ))
expect_equal(or3s(logi_ii, , ),
bor3(logi_ii, , ))
expect_equal(or3s(logi_ij, , z > 0L),
bor3(logi_ij, , z > 0L))
expect_equal(or3s(logi_ik, , r > 1L),
bor3(logi_ik, , r > 1L))
expect_equal(or3s(logi_il, , e > 9L),
bor3(logi_il, , e > 9L))
expect_equal(or3s(logi_im, !logi_d, ),
bor3(logi_im, !logi_d, ))
expect_equal(or3s(logi_IN, !logi_o, ),
bor3(logi_IN, !logi_o, ))
expect_equal(or3s(logi_io, !logi_o, ),
bor3(logi_io, !logi_o, ))
expect_equal(or3s(logi_ip, !logi_f, m > 0L),
bor3(logi_ip, !logi_f, m > 0L))
expect_equal(or3s(logi_iq, !logi_i, y > 1L),
bor3(logi_iq, !logi_i, y > 1L))
expect_equal(or3s(logi_ir, !logi_w, s > 9L),
bor3(logi_ir, !logi_w, s > 9L))
expect_equal(or3s(logi_is, , ),
bor3(logi_is, , ))
expect_equal(or3s(logi_it, , ),
bor3(logi_it, , ))
expect_equal(or3s(logi_iu, , ),
bor3(logi_iu, , ))
expect_equal(or3s(logi_iv, , y >= 0L),
bor3(logi_iv, , y >= 0L))
expect_equal(or3s(logi_iw, , d >= 1L),
bor3(logi_iw, , d >= 1L))
expect_equal(or3s(logi_ix, , w >= 9L),
bor3(logi_ix, , w >= 9L))
expect_equal(or3s(logi_iy, !logi_i, ),
bor3(logi_iy, !logi_i, ))
expect_equal(or3s(logi_iz, !logi_f, ),
bor3(logi_iz, !logi_f, ))
expect_equal(or3s(logi_ja, !logi_x, ),
bor3(logi_ja, !logi_x, ))
expect_equal(or3s(logi_jb, !logi_j, e >= 0L),
bor3(logi_jb, !logi_j, e >= 0L))
expect_equal(or3s(logi_jc, !logi_v, j >= 1L),
bor3(logi_jc, !logi_v, j >= 1L))
expect_equal(or3s(logi_jd, !logi_q, x >= 9L),
bor3(logi_jd, !logi_q, x >= 9L))
expect_equal(or3s(logi_je, , ),
bor3(logi_je, , ))
expect_equal(or3s(logi_jf, , ),
bor3(logi_jf, , ))
expect_equal(or3s(logi_jg, , ),
bor3(logi_jg, , ))
expect_equal(or3s(logi_jh, , logi_q),
bor3(logi_jh, , logi_q))
expect_equal(or3s(logi_ji, , logi_x),
bor3(logi_ji, , logi_x))
expect_equal(or3s(logi_jj, , logi_z),
bor3(logi_jj, , logi_z))
expect_equal(or3s(logi_jk, j != 0L, ),
bor3(logi_jk, j != 0L, ))
expect_equal(or3s(logi_jl, m != 1L, ),
bor3(logi_jl, m != 1L, ))
expect_equal(or3s(logi_jm, o != 9L, ),
bor3(logi_jm, o != 9L, ))
expect_equal(or3s(logi_jn, f != 0L, logi_u),
bor3(logi_jn, f != 0L, logi_u))
expect_equal(or3s(logi_jo, f != 1L, logi_q),
bor3(logi_jo, f != 1L, logi_q))
expect_equal(or3s(logi_jp, w != 9L, logi_x),
bor3(logi_jp, w != 9L, logi_x))
expect_equal(or3s(logi_jq, , ),
bor3(logi_jq, , ))
expect_equal(or3s(logi_jr, , ),
bor3(logi_jr, , ))
expect_equal(or3s(logi_js, , ),
bor3(logi_js, , ))
expect_equal(or3s(logi_jt, , !logi_s),
bor3(logi_jt, , !logi_s))
expect_equal(or3s(logi_ju, , !logi_n),
bor3(logi_ju, , !logi_n))
expect_equal(or3s(logi_jv, , !logi_z),
bor3(logi_jv, , !logi_z))
expect_equal(or3s(logi_jw, c != 0L, ),
bor3(logi_jw, c != 0L, ))
expect_equal(or3s(logi_jx, h != 1L, ),
bor3(logi_jx, h != 1L, ))
expect_equal(or3s(logi_jy, c != 9L, ),
bor3(logi_jy, c != 9L, ))
expect_equal(or3s(logi_jz, d != 0L, !logi_a),
bor3(logi_jz, d != 0L, !logi_a))
expect_equal(or3s(logi_ka, x != 1L, !logi_i),
bor3(logi_ka, x != 1L, !logi_i))
expect_equal(or3s(logi_kb, s != 9L, !logi_r),
bor3(logi_kb, s != 9L, !logi_r))
expect_equal(or3s(logi_kc, , ),
bor3(logi_kc, , ))
expect_equal(or3s(logi_kd, , ),
bor3(logi_kd, , ))
expect_equal(or3s(logi_ke, , ),
bor3(logi_ke, , ))
expect_equal(or3s(logi_kf, , r != 0L),
bor3(logi_kf, , r != 0L))
expect_equal(or3s(logi_kg, , z != 1L),
bor3(logi_kg, , z != 1L))
expect_equal(or3s(logi_kh, , h != 9L),
bor3(logi_kh, , h != 9L))
expect_equal(or3s(logi_ki, a != 0L, ),
bor3(logi_ki, a != 0L, ))
expect_equal(or3s(logi_kj, u != 1L, ),
bor3(logi_kj, u != 1L, ))
expect_equal(or3s(logi_kk, j != 9L, ),
bor3(logi_kk, j != 9L, ))
expect_equal(or3s(logi_kl, m != 0L, g != 0L),
bor3(logi_kl, m != 0L, g != 0L))
expect_equal(or3s(logi_km, m != 1L, l != 1L),
bor3(logi_km, m != 1L, l != 1L))
expect_equal(or3s(logi_kn, b != 9L, u != 9L),
bor3(logi_kn, b != 9L, u != 9L))
expect_equal(or3s(logi_ko, , ),
bor3(logi_ko, , ))
expect_equal(or3s(logi_kp, , ),
bor3(logi_kp, , ))
expect_equal(or3s(logi_kq, , ),
bor3(logi_kq, , ))
expect_equal(or3s(logi_kr, , i %between% c(-1L, 1L)),
bor3(logi_kr, , i %between% c(-1L, 1L)))
expect_equal(or3s(logi_ks, , o %between% c(-1L, 1L)),
bor3(logi_ks, , o %between% c(-1L, 1L)))
expect_equal(or3s(logi_kt, , j %between% c(-1L, 1L)),
bor3(logi_kt, , j %between% c(-1L, 1L)))
expect_equal(or3s(logi_ku, g != 0L, ),
bor3(logi_ku, g != 0L, ))
expect_equal(or3s(logi_kv, m != 1L, ),
bor3(logi_kv, m != 1L, ))
expect_equal(or3s(logi_kw, b != 9L, ),
bor3(logi_kw, b != 9L, ))
expect_equal(or3s(logi_kx, f != 0L, e %between% c(-1L, 1L)),
bor3(logi_kx, f != 0L, e %between% c(-1L, 1L)))
expect_equal(or3s(logi_ky, w != 1L, j %between% c(-1L, 1L)),
bor3(logi_ky, w != 1L, j %between% c(-1L, 1L)))
expect_equal(or3s(logi_kz, e != 9L, w %between% c(-1L, 1L)),
bor3(logi_kz, e != 9L, w %between% c(-1L, 1L)))
expect_equal(or3s(logi_la, , ),
bor3(logi_la, , ))
expect_equal(or3s(logi_lb, , ),
bor3(logi_lb, , ))
expect_equal(or3s(logi_lc, , ),
bor3(logi_lc, , ))
expect_equal(or3s(logi_ld, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ld, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_le, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_le, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_lf, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_lf, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_lg, m != 0L, ),
bor3(logi_lg, m != 0L, ))
expect_equal(or3s(logi_lh, c != 1L, ),
bor3(logi_lh, c != 1L, ))
expect_equal(or3s(logi_li, j != 9L, ),
bor3(logi_li, j != 9L, ))
expect_equal(or3s(logi_lj, v != 0L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_lj, v != 0L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_lk, p != 1L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_lk, p != 1L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ll, a != 9L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ll, a != 9L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_lm, , ),
bor3(logi_lm, , ))
expect_equal(or3s(logi_ln, , ),
bor3(logi_ln, , ))
expect_equal(or3s(logi_lo, , ),
bor3(logi_lo, , ))
expect_equal(or3s(logi_lp, , h %in% 1:4),
bor3(logi_lp, , h %in% 1:4))
expect_equal(or3s(logi_lq, , n %in% 1:4),
bor3(logi_lq, , n %in% 1:4))
expect_equal(or3s(logi_lr, , t %in% 1:4),
bor3(logi_lr, , t %in% 1:4))
expect_equal(or3s(logi_ls, k != 0L, ),
bor3(logi_ls, k != 0L, ))
expect_equal(or3s(logi_lt, w != 1L, ),
bor3(logi_lt, w != 1L, ))
expect_equal(or3s(logi_lu, j != 9L, ),
bor3(logi_lu, j != 9L, ))
expect_equal(or3s(logi_lv, s != 0L, o %in% 1:4),
bor3(logi_lv, s != 0L, o %in% 1:4))
expect_equal(or3s(logi_lw, b != 1L, u %in% 1:4),
bor3(logi_lw, b != 1L, u %in% 1:4))
expect_equal(or3s(logi_lx, n != 9L, x %in% 1:4),
bor3(logi_lx, n != 9L, x %in% 1:4))
expect_equal(or3s(logi_ly, , ),
bor3(logi_ly, , ))
expect_equal(or3s(logi_lz, , ),
bor3(logi_lz, , ))
expect_equal(or3s(logi_ma, , ),
bor3(logi_ma, , ))
expect_equal(or3s(logi_mb, , i < 0L),
bor3(logi_mb, , i < 0L))
expect_equal(or3s(logi_mc, , d < 1L),
bor3(logi_mc, , d < 1L))
expect_equal(or3s(logi_md, , r < 9L),
bor3(logi_md, , r < 9L))
expect_equal(or3s(logi_me, e != 0L, ),
bor3(logi_me, e != 0L, ))
expect_equal(or3s(logi_mf, d != 1L, ),
bor3(logi_mf, d != 1L, ))
expect_equal(or3s(logi_mg, k != 9L, ),
bor3(logi_mg, k != 9L, ))
expect_equal(or3s(logi_mh, n != 0L, c < 0L),
bor3(logi_mh, n != 0L, c < 0L))
expect_equal(or3s(logi_mi, u != 1L, t < 1L),
bor3(logi_mi, u != 1L, t < 1L))
expect_equal(or3s(logi_mj, x != 9L, r < 9L),
bor3(logi_mj, x != 9L, r < 9L))
expect_equal(or3s(logi_mk, , ),
bor3(logi_mk, , ))
expect_equal(or3s(logi_ml, , ),
bor3(logi_ml, , ))
expect_equal(or3s(logi_mm, , ),
bor3(logi_mm, , ))
expect_equal(or3s(logi_mn, , h <= 0L),
bor3(logi_mn, , h <= 0L))
expect_equal(or3s(logi_mo, , i <= 1L),
bor3(logi_mo, , i <= 1L))
expect_equal(or3s(logi_mp, , n <= 9L),
bor3(logi_mp, , n <= 9L))
expect_equal(or3s(logi_mq, q != 0L, ),
bor3(logi_mq, q != 0L, ))
expect_equal(or3s(logi_mr, l != 1L, ),
bor3(logi_mr, l != 1L, ))
expect_equal(or3s(logi_ms, a != 9L, ),
bor3(logi_ms, a != 9L, ))
expect_equal(or3s(logi_mt, o != 0L, a <= 0L),
bor3(logi_mt, o != 0L, a <= 0L))
expect_equal(or3s(logi_mu, z != 1L, e <= 1L),
bor3(logi_mu, z != 1L, e <= 1L))
expect_equal(or3s(logi_mv, k != 9L, l <= 9L),
bor3(logi_mv, k != 9L, l <= 9L))
expect_equal(or3s(logi_mw, , ),
bor3(logi_mw, , ))
expect_equal(or3s(logi_mx, , ),
bor3(logi_mx, , ))
expect_equal(or3s(logi_my, , ),
bor3(logi_my, , ))
expect_equal(or3s(logi_mz, , i == 0L),
bor3(logi_mz, , i == 0L))
expect_equal(or3s(logi_na, , g == 1L),
bor3(logi_na, , g == 1L))
expect_equal(or3s(logi_nb, , b == 9L),
bor3(logi_nb, , b == 9L))
expect_equal(or3s(logi_nc, t != 0L, ),
bor3(logi_nc, t != 0L, ))
expect_equal(or3s(logi_nd, l != 1L, ),
bor3(logi_nd, l != 1L, ))
expect_equal(or3s(logi_ne, b != 9L, ),
bor3(logi_ne, b != 9L, ))
expect_equal(or3s(logi_nf, j != 0L, s == 0L),
bor3(logi_nf, j != 0L, s == 0L))
expect_equal(or3s(logi_ng, z != 1L, x == 1L),
bor3(logi_ng, z != 1L, x == 1L))
expect_equal(or3s(logi_nh, f != 9L, k == 9L),
bor3(logi_nh, f != 9L, k == 9L))
expect_equal(or3s(logi_ni, , ),
bor3(logi_ni, , ))
expect_equal(or3s(logi_nj, , ),
bor3(logi_nj, , ))
expect_equal(or3s(logi_nk, , ),
bor3(logi_nk, , ))
expect_equal(or3s(logi_nl, , x > 0L),
bor3(logi_nl, , x > 0L))
expect_equal(or3s(logi_nm, , b > 1L),
bor3(logi_nm, , b > 1L))
expect_equal(or3s(logi_nn, , r > 9L),
bor3(logi_nn, , r > 9L))
expect_equal(or3s(logi_no, f != 0L, ),
bor3(logi_no, f != 0L, ))
expect_equal(or3s(logi_np, z != 1L, ),
bor3(logi_np, z != 1L, ))
expect_equal(or3s(logi_nq, m != 9L, ),
bor3(logi_nq, m != 9L, ))
expect_equal(or3s(logi_nr, b != 0L, o > 0L),
bor3(logi_nr, b != 0L, o > 0L))
expect_equal(or3s(logi_ns, q != 1L, d > 1L),
bor3(logi_ns, q != 1L, d > 1L))
expect_equal(or3s(logi_nt, k != 9L, z > 9L),
bor3(logi_nt, k != 9L, z > 9L))
expect_equal(or3s(logi_nu, , ),
bor3(logi_nu, , ))
expect_equal(or3s(logi_nv, , ),
bor3(logi_nv, , ))
expect_equal(or3s(logi_nw, , ),
bor3(logi_nw, , ))
expect_equal(or3s(logi_nx, , u >= 0L),
bor3(logi_nx, , u >= 0L))
expect_equal(or3s(logi_ny, , j >= 1L),
bor3(logi_ny, , j >= 1L))
expect_equal(or3s(logi_nz, , j >= 9L),
bor3(logi_nz, , j >= 9L))
expect_equal(or3s(logi_oa, t != 0L, ),
bor3(logi_oa, t != 0L, ))
expect_equal(or3s(logi_ob, n != 1L, ),
bor3(logi_ob, n != 1L, ))
expect_equal(or3s(logi_oc, b != 9L, ),
bor3(logi_oc, b != 9L, ))
expect_equal(or3s(logi_od, r != 0L, c >= 0L),
bor3(logi_od, r != 0L, c >= 0L))
expect_equal(or3s(logi_oe, c != 1L, m >= 1L),
bor3(logi_oe, c != 1L, m >= 1L))
expect_equal(or3s(logi_of, c != 9L, h >= 9L),
bor3(logi_of, c != 9L, h >= 9L))
expect_equal(or3s(logi_og, , ),
bor3(logi_og, , ))
expect_equal(or3s(logi_oh, , ),
bor3(logi_oh, , ))
expect_equal(or3s(logi_oi, , ),
bor3(logi_oi, , ))
expect_equal(or3s(logi_oj, , logi_q),
bor3(logi_oj, , logi_q))
expect_equal(or3s(logi_ok, , logi_m),
bor3(logi_ok, , logi_m))
expect_equal(or3s(logi_ol, , logi_p),
bor3(logi_ol, , logi_p))
expect_equal(or3s(logi_om, w %between% c(-1L, 1L), ),
bor3(logi_om, w %between% c(-1L, 1L), ))
expect_equal(or3s(logi_on, k %between% c(-1L, 1L), ),
bor3(logi_on, k %between% c(-1L, 1L), ))
expect_equal(or3s(logi_oo, w %between% c(-1L, 1L), ),
bor3(logi_oo, w %between% c(-1L, 1L), ))
expect_equal(or3s(logi_op, g %between% c(-1L, 1L), logi_j),
bor3(logi_op, g %between% c(-1L, 1L), logi_j))
expect_equal(or3s(logi_oq, z %between% c(-1L, 1L), logi_z),
bor3(logi_oq, z %between% c(-1L, 1L), logi_z))
expect_equal(or3s(logi_or, x %between% c(-1L, 1L), logi_d),
bor3(logi_or, x %between% c(-1L, 1L), logi_d))
expect_equal(or3s(logi_os, , ),
bor3(logi_os, , ))
expect_equal(or3s(logi_ot, , ),
bor3(logi_ot, , ))
expect_equal(or3s(logi_ou, , ),
bor3(logi_ou, , ))
expect_equal(or3s(logi_ov, , !logi_i),
bor3(logi_ov, , !logi_i))
expect_equal(or3s(logi_ow, , !logi_b),
bor3(logi_ow, , !logi_b))
expect_equal(or3s(logi_ox, , !logi_b),
bor3(logi_ox, , !logi_b))
expect_equal(or3s(logi_oy, r %between% c(-1L, 1L), ),
bor3(logi_oy, r %between% c(-1L, 1L), ))
expect_equal(or3s(logi_oz, f %between% c(-1L, 1L), ),
bor3(logi_oz, f %between% c(-1L, 1L), ))
expect_equal(or3s(logi_pa, o %between% c(-1L, 1L), ),
bor3(logi_pa, o %between% c(-1L, 1L), ))
expect_equal(or3s(logi_pb, l %between% c(-1L, 1L), !logi_s),
bor3(logi_pb, l %between% c(-1L, 1L), !logi_s))
expect_equal(or3s(logi_pc, g %between% c(-1L, 1L), !logi_w),
bor3(logi_pc, g %between% c(-1L, 1L), !logi_w))
expect_equal(or3s(logi_pd, s %between% c(-1L, 1L), !logi_y),
bor3(logi_pd, s %between% c(-1L, 1L), !logi_y))
expect_equal(or3s(logi_pe, , ),
bor3(logi_pe, , ))
expect_equal(or3s(logi_pf, , ),
bor3(logi_pf, , ))
expect_equal(or3s(logi_pg, , ),
bor3(logi_pg, , ))
expect_equal(or3s(logi_ph, , m != 0L),
bor3(logi_ph, , m != 0L))
expect_equal(or3s(logi_pi, , u != 1L),
bor3(logi_pi, , u != 1L))
expect_equal(or3s(logi_pj, , d != 9L),
bor3(logi_pj, , d != 9L))
expect_equal(or3s(logi_pk, p %between% c(-1L, 1L), ),
bor3(logi_pk, p %between% c(-1L, 1L), ))
expect_equal(or3s(logi_pl, n %between% c(-1L, 1L), ),
bor3(logi_pl, n %between% c(-1L, 1L), ))
expect_equal(or3s(logi_pm, u %between% c(-1L, 1L), ),
bor3(logi_pm, u %between% c(-1L, 1L), ))
expect_equal(or3s(logi_pn, h %between% c(-1L, 1L), v != 0L),
bor3(logi_pn, h %between% c(-1L, 1L), v != 0L))
expect_equal(or3s(logi_po, y %between% c(-1L, 1L), y != 1L),
bor3(logi_po, y %between% c(-1L, 1L), y != 1L))
expect_equal(or3s(logi_pp, t %between% c(-1L, 1L), e != 9L),
bor3(logi_pp, t %between% c(-1L, 1L), e != 9L))
expect_equal(or3s(logi_pq, , ),
bor3(logi_pq, , ))
expect_equal(or3s(logi_pr, , ),
bor3(logi_pr, , ))
expect_equal(or3s(logi_ps, , ),
bor3(logi_ps, , ))
expect_equal(or3s(logi_pt, , w %between% c(-1L, 1L)),
bor3(logi_pt, , w %between% c(-1L, 1L)))
expect_equal(or3s(logi_pu, , o %between% c(-1L, 1L)),
bor3(logi_pu, , o %between% c(-1L, 1L)))
expect_equal(or3s(logi_pv, , n %between% c(-1L, 1L)),
bor3(logi_pv, , n %between% c(-1L, 1L)))
expect_equal(or3s(logi_pw, f %between% c(-1L, 1L), ),
bor3(logi_pw, f %between% c(-1L, 1L), ))
expect_equal(or3s(logi_px, t %between% c(-1L, 1L), ),
bor3(logi_px, t %between% c(-1L, 1L), ))
expect_equal(or3s(logi_py, z %between% c(-1L, 1L), ),
bor3(logi_py, z %between% c(-1L, 1L), ))
expect_equal(or3s(logi_pz, d %between% c(-1L, 1L), p %between% c(-1L, 1L)),
bor3(logi_pz, d %between% c(-1L, 1L), p %between% c(-1L, 1L)))
expect_equal(or3s(logi_qa, t %between% c(-1L, 1L), j %between% c(-1L, 1L)),
bor3(logi_qa, t %between% c(-1L, 1L), j %between% c(-1L, 1L)))
expect_equal(or3s(logi_qb, i %between% c(-1L, 1L), n %between% c(-1L, 1L)),
bor3(logi_qb, i %between% c(-1L, 1L), n %between% c(-1L, 1L)))
expect_equal(or3s(logi_qc, , ),
bor3(logi_qc, , ))
expect_equal(or3s(logi_qd, , ),
bor3(logi_qd, , ))
expect_equal(or3s(logi_qe, , ),
bor3(logi_qe, , ))
expect_equal(or3s(logi_qf, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_qf, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_qg, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_qg, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_qh, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_qh, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_qi, u %between% c(-1L, 1L), ),
bor3(logi_qi, u %between% c(-1L, 1L), ))
expect_equal(or3s(logi_qj, d %between% c(-1L, 1L), ),
bor3(logi_qj, d %between% c(-1L, 1L), ))
expect_equal(or3s(logi_qk, p %between% c(-1L, 1L), ),
bor3(logi_qk, p %between% c(-1L, 1L), ))
expect_equal(or3s(logi_ql, r %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ql, r %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_qm, n %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_qm, n %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_qn, m %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_qn, m %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_qo, , ),
bor3(logi_qo, , ))
expect_equal(or3s(logi_qp, , ),
bor3(logi_qp, , ))
expect_equal(or3s(logi_qq, , ),
bor3(logi_qq, , ))
expect_equal(or3s(logi_qr, , f %in% 1:4),
bor3(logi_qr, , f %in% 1:4))
expect_equal(or3s(logi_qs, , s %in% 1:4),
bor3(logi_qs, , s %in% 1:4))
expect_equal(or3s(logi_qt, , d %in% 1:4),
bor3(logi_qt, , d %in% 1:4))
expect_equal(or3s(logi_qu, c %between% c(-1L, 1L), ),
bor3(logi_qu, c %between% c(-1L, 1L), ))
expect_equal(or3s(logi_qv, l %between% c(-1L, 1L), ),
bor3(logi_qv, l %between% c(-1L, 1L), ))
expect_equal(or3s(logi_qw, d %between% c(-1L, 1L), ),
bor3(logi_qw, d %between% c(-1L, 1L), ))
expect_equal(or3s(logi_qx, b %between% c(-1L, 1L), y %in% 1:4),
bor3(logi_qx, b %between% c(-1L, 1L), y %in% 1:4))
expect_equal(or3s(logi_qy, m %between% c(-1L, 1L), f %in% 1:4),
bor3(logi_qy, m %between% c(-1L, 1L), f %in% 1:4))
expect_equal(or3s(logi_qz, z %between% c(-1L, 1L), a %in% 1:4),
bor3(logi_qz, z %between% c(-1L, 1L), a %in% 1:4))
expect_equal(or3s(logi_ra, , ),
bor3(logi_ra, , ))
expect_equal(or3s(logi_rb, , ),
bor3(logi_rb, , ))
expect_equal(or3s(logi_rc, , ),
bor3(logi_rc, , ))
expect_equal(or3s(logi_rd, , n < 0L),
bor3(logi_rd, , n < 0L))
expect_equal(or3s(logi_re, , u < 1L),
bor3(logi_re, , u < 1L))
expect_equal(or3s(logi_rf, , l < 9L),
bor3(logi_rf, , l < 9L))
expect_equal(or3s(logi_rg, z %between% c(-1L, 1L), ),
bor3(logi_rg, z %between% c(-1L, 1L), ))
expect_equal(or3s(logi_rh, u %between% c(-1L, 1L), ),
bor3(logi_rh, u %between% c(-1L, 1L), ))
expect_equal(or3s(logi_ri, y %between% c(-1L, 1L), ),
bor3(logi_ri, y %between% c(-1L, 1L), ))
expect_equal(or3s(logi_rj, o %between% c(-1L, 1L), d < 0L),
bor3(logi_rj, o %between% c(-1L, 1L), d < 0L))
expect_equal(or3s(logi_rk, a %between% c(-1L, 1L), j < 1L),
bor3(logi_rk, a %between% c(-1L, 1L), j < 1L))
expect_equal(or3s(logi_rl, z %between% c(-1L, 1L), r < 9L),
bor3(logi_rl, z %between% c(-1L, 1L), r < 9L))
expect_equal(or3s(logi_rm, , ),
bor3(logi_rm, , ))
expect_equal(or3s(logi_rn, , ),
bor3(logi_rn, , ))
expect_equal(or3s(logi_ro, , ),
bor3(logi_ro, , ))
expect_equal(or3s(logi_rp, , s <= 0L),
bor3(logi_rp, , s <= 0L))
expect_equal(or3s(logi_rq, , l <= 1L),
bor3(logi_rq, , l <= 1L))
expect_equal(or3s(logi_rr, , n <= 9L),
bor3(logi_rr, , n <= 9L))
expect_equal(or3s(logi_rs, b %between% c(-1L, 1L), ),
bor3(logi_rs, b %between% c(-1L, 1L), ))
expect_equal(or3s(logi_rt, n %between% c(-1L, 1L), ),
bor3(logi_rt, n %between% c(-1L, 1L), ))
expect_equal(or3s(logi_ru, g %between% c(-1L, 1L), ),
bor3(logi_ru, g %between% c(-1L, 1L), ))
expect_equal(or3s(logi_rv, n %between% c(-1L, 1L), o <= 0L),
bor3(logi_rv, n %between% c(-1L, 1L), o <= 0L))
expect_equal(or3s(logi_rw, i %between% c(-1L, 1L), k <= 1L),
bor3(logi_rw, i %between% c(-1L, 1L), k <= 1L))
expect_equal(or3s(logi_rx, z %between% c(-1L, 1L), q <= 9L),
bor3(logi_rx, z %between% c(-1L, 1L), q <= 9L))
expect_equal(or3s(logi_ry, , ),
bor3(logi_ry, , ))
expect_equal(or3s(logi_rz, , ),
bor3(logi_rz, , ))
expect_equal(or3s(logi_sa, , ),
bor3(logi_sa, , ))
expect_equal(or3s(logi_sb, , m == 0L),
bor3(logi_sb, , m == 0L))
expect_equal(or3s(logi_sc, , u == 1L),
bor3(logi_sc, , u == 1L))
expect_equal(or3s(logi_sd, , t == 9L),
bor3(logi_sd, , t == 9L))
expect_equal(or3s(logi_se, n %between% c(-1L, 1L), ),
bor3(logi_se, n %between% c(-1L, 1L), ))
expect_equal(or3s(logi_sf, f %between% c(-1L, 1L), ),
bor3(logi_sf, f %between% c(-1L, 1L), ))
expect_equal(or3s(logi_sg, n %between% c(-1L, 1L), ),
bor3(logi_sg, n %between% c(-1L, 1L), ))
expect_equal(or3s(logi_sh, i %between% c(-1L, 1L), e == 0L),
bor3(logi_sh, i %between% c(-1L, 1L), e == 0L))
expect_equal(or3s(logi_si, f %between% c(-1L, 1L), b == 1L),
bor3(logi_si, f %between% c(-1L, 1L), b == 1L))
expect_equal(or3s(logi_sj, b %between% c(-1L, 1L), t == 9L),
bor3(logi_sj, b %between% c(-1L, 1L), t == 9L))
expect_equal(or3s(logi_sk, , ),
bor3(logi_sk, , ))
expect_equal(or3s(logi_sl, , ),
bor3(logi_sl, , ))
expect_equal(or3s(logi_sm, , ),
bor3(logi_sm, , ))
expect_equal(or3s(logi_sn, , g > 0L),
bor3(logi_sn, , g > 0L))
expect_equal(or3s(logi_so, , w > 1L),
bor3(logi_so, , w > 1L))
expect_equal(or3s(logi_sp, , n > 9L),
bor3(logi_sp, , n > 9L))
expect_equal(or3s(logi_sq, q %between% c(-1L, 1L), ),
bor3(logi_sq, q %between% c(-1L, 1L), ))
expect_equal(or3s(logi_sr, v %between% c(-1L, 1L), ),
bor3(logi_sr, v %between% c(-1L, 1L), ))
expect_equal(or3s(logi_ss, j %between% c(-1L, 1L), ),
bor3(logi_ss, j %between% c(-1L, 1L), ))
expect_equal(or3s(logi_st, a %between% c(-1L, 1L), a > 0L),
bor3(logi_st, a %between% c(-1L, 1L), a > 0L))
expect_equal(or3s(logi_su, y %between% c(-1L, 1L), i > 1L),
bor3(logi_su, y %between% c(-1L, 1L), i > 1L))
expect_equal(or3s(logi_sv, p %between% c(-1L, 1L), c > 9L),
bor3(logi_sv, p %between% c(-1L, 1L), c > 9L))
expect_equal(or3s(logi_sw, , ),
bor3(logi_sw, , ))
expect_equal(or3s(logi_sx, , ),
bor3(logi_sx, , ))
expect_equal(or3s(logi_sy, , ),
bor3(logi_sy, , ))
expect_equal(or3s(logi_sz, , h >= 0L),
bor3(logi_sz, , h >= 0L))
expect_equal(or3s(logi_ta, , d >= 1L),
bor3(logi_ta, , d >= 1L))
expect_equal(or3s(logi_tb, , m >= 9L),
bor3(logi_tb, , m >= 9L))
expect_equal(or3s(logi_tc, f %between% c(-1L, 1L), ),
bor3(logi_tc, f %between% c(-1L, 1L), ))
expect_equal(or3s(logi_td, z %between% c(-1L, 1L), ),
bor3(logi_td, z %between% c(-1L, 1L), ))
expect_equal(or3s(logi_te, e %between% c(-1L, 1L), ),
bor3(logi_te, e %between% c(-1L, 1L), ))
expect_equal(or3s(logi_tf, s %between% c(-1L, 1L), c >= 0L),
bor3(logi_tf, s %between% c(-1L, 1L), c >= 0L))
expect_equal(or3s(logi_tg, c %between% c(-1L, 1L), q >= 1L),
bor3(logi_tg, c %between% c(-1L, 1L), q >= 1L))
expect_equal(or3s(logi_th, r %between% c(-1L, 1L), v >= 9L),
bor3(logi_th, r %between% c(-1L, 1L), v >= 9L))
expect_equal(or3s(logi_ti, , ),
bor3(logi_ti, , ))
expect_equal(or3s(logi_tj, , ),
bor3(logi_tj, , ))
expect_equal(or3s(logi_tk, , ),
bor3(logi_tk, , ))
expect_equal(or3s(logi_tl, , logi_n),
bor3(logi_tl, , logi_n))
expect_equal(or3s(logi_tm, , logi_c),
bor3(logi_tm, , logi_c))
expect_equal(or3s(logi_tn, , logi_a),
bor3(logi_tn, , logi_a))
expect_equal(or3s(logi_to, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_to, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_tp, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_tp, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_tq, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_tq, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_tr, j %in% c(4L, -3L, 2L, 7L, 8L), logi_p),
bor3(logi_tr, j %in% c(4L, -3L, 2L, 7L, 8L), logi_p))
expect_equal(or3s(logi_ts, v %in% c(4L, -3L, 2L, 7L, 8L), logi_u),
bor3(logi_ts, v %in% c(4L, -3L, 2L, 7L, 8L), logi_u))
expect_equal(or3s(logi_tt, g %in% c(4L, -3L, 2L, 7L, 8L), logi_l),
bor3(logi_tt, g %in% c(4L, -3L, 2L, 7L, 8L), logi_l))
expect_equal(or3s(logi_tu, , ),
bor3(logi_tu, , ))
expect_equal(or3s(logi_tv, , ),
bor3(logi_tv, , ))
expect_equal(or3s(logi_tw, , ),
bor3(logi_tw, , ))
expect_equal(or3s(logi_tx, , logi_c),
bor3(logi_tx, , logi_c))
expect_equal(or3s(logi_ty, , logi_y),
bor3(logi_ty, , logi_y))
expect_equal(or3s(logi_tz, , logi_d),
bor3(logi_tz, , logi_d))
expect_equal(or3s(logi_ua, m %in% 1:4, ),
bor3(logi_ua, m %in% 1:4, ))
expect_equal(or3s(logi_ub, j %in% 1:4, ),
bor3(logi_ub, j %in% 1:4, ))
expect_equal(or3s(logi_uc, n %in% 1:4, ),
bor3(logi_uc, n %in% 1:4, ))
expect_equal(or3s(logi_ud, h %in% 1:4, logi_h),
bor3(logi_ud, h %in% 1:4, logi_h))
expect_equal(or3s(logi_ue, b %in% 1:4, logi_k),
bor3(logi_ue, b %in% 1:4, logi_k))
expect_equal(or3s(logi_uf, a %in% 1:4, logi_i),
bor3(logi_uf, a %in% 1:4, logi_i))
expect_equal(or3s(logi_ug, , ),
bor3(logi_ug, , ))
expect_equal(or3s(logi_uh, , ),
bor3(logi_uh, , ))
expect_equal(or3s(logi_ui, , ),
bor3(logi_ui, , ))
expect_equal(or3s(logi_uj, , !logi_f),
bor3(logi_uj, , !logi_f))
expect_equal(or3s(logi_uk, , !logi_o),
bor3(logi_uk, , !logi_o))
expect_equal(or3s(logi_ul, , !logi_n),
bor3(logi_ul, , !logi_n))
expect_equal(or3s(logi_um, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_um, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_un, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_un, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_uo, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_uo, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_up, s %in% c(4L, -3L, 2L, 7L, 8L), !logi_b),
bor3(logi_up, s %in% c(4L, -3L, 2L, 7L, 8L), !logi_b))
expect_equal(or3s(logi_uq, u %in% c(4L, -3L, 2L, 7L, 8L), !logi_z),
bor3(logi_uq, u %in% c(4L, -3L, 2L, 7L, 8L), !logi_z))
expect_equal(or3s(logi_ur, l %in% c(4L, -3L, 2L, 7L, 8L), !logi_w),
bor3(logi_ur, l %in% c(4L, -3L, 2L, 7L, 8L), !logi_w))
expect_equal(or3s(logi_us, , ),
bor3(logi_us, , ))
expect_equal(or3s(logi_ut, , ),
bor3(logi_ut, , ))
expect_equal(or3s(logi_uu, , ),
bor3(logi_uu, , ))
expect_equal(or3s(logi_uv, , !logi_x),
bor3(logi_uv, , !logi_x))
expect_equal(or3s(logi_uw, , !logi_g),
bor3(logi_uw, , !logi_g))
expect_equal(or3s(logi_ux, , !logi_z),
bor3(logi_ux, , !logi_z))
expect_equal(or3s(logi_uy, u %in% 1:4, ),
bor3(logi_uy, u %in% 1:4, ))
expect_equal(or3s(logi_uz, f %in% 1:4, ),
bor3(logi_uz, f %in% 1:4, ))
expect_equal(or3s(logi_va, r %in% 1:4, ),
bor3(logi_va, r %in% 1:4, ))
expect_equal(or3s(logi_vb, b %in% 1:4, !logi_m),
bor3(logi_vb, b %in% 1:4, !logi_m))
expect_equal(or3s(logi_vc, y %in% 1:4, !logi_h),
bor3(logi_vc, y %in% 1:4, !logi_h))
expect_equal(or3s(logi_vd, w %in% 1:4, !logi_a),
bor3(logi_vd, w %in% 1:4, !logi_a))
expect_equal(or3s(logi_ve, , ),
bor3(logi_ve, , ))
expect_equal(or3s(logi_vf, , ),
bor3(logi_vf, , ))
expect_equal(or3s(logi_vg, , ),
bor3(logi_vg, , ))
expect_equal(or3s(logi_vh, , x != 0L),
bor3(logi_vh, , x != 0L))
expect_equal(or3s(logi_vi, , i != 1L),
bor3(logi_vi, , i != 1L))
expect_equal(or3s(logi_vj, , l != 9L),
bor3(logi_vj, , l != 9L))
expect_equal(or3s(logi_vk, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_vk, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_vl, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_vl, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_vm, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_vm, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_vn, w %in% c(4L, -3L, 2L, 7L, 8L), o != 0L),
bor3(logi_vn, w %in% c(4L, -3L, 2L, 7L, 8L), o != 0L))
expect_equal(or3s(logi_vo, o %in% c(4L, -3L, 2L, 7L, 8L), k != 1L),
bor3(logi_vo, o %in% c(4L, -3L, 2L, 7L, 8L), k != 1L))
expect_equal(or3s(logi_vp, g %in% c(4L, -3L, 2L, 7L, 8L), m != 9L),
bor3(logi_vp, g %in% c(4L, -3L, 2L, 7L, 8L), m != 9L))
expect_equal(or3s(logi_vq, , ),
bor3(logi_vq, , ))
expect_equal(or3s(logi_vr, , ),
bor3(logi_vr, , ))
expect_equal(or3s(logi_vs, , ),
bor3(logi_vs, , ))
expect_equal(or3s(logi_vt, , x != 0L),
bor3(logi_vt, , x != 0L))
expect_equal(or3s(logi_vu, , l != 1L),
bor3(logi_vu, , l != 1L))
expect_equal(or3s(logi_vv, , m != 9L),
bor3(logi_vv, , m != 9L))
expect_equal(or3s(logi_vw, z %in% 1:4, ),
bor3(logi_vw, z %in% 1:4, ))
expect_equal(or3s(logi_vx, h %in% 1:4, ),
bor3(logi_vx, h %in% 1:4, ))
expect_equal(or3s(logi_vy, i %in% 1:4, ),
bor3(logi_vy, i %in% 1:4, ))
expect_equal(or3s(logi_vz, p %in% 1:4, v != 0L),
bor3(logi_vz, p %in% 1:4, v != 0L))
expect_equal(or3s(logi_wa, s %in% 1:4, o != 1L),
bor3(logi_wa, s %in% 1:4, o != 1L))
expect_equal(or3s(logi_wb, d %in% 1:4, a != 9L),
bor3(logi_wb, d %in% 1:4, a != 9L))
expect_equal(or3s(logi_wc, , ),
bor3(logi_wc, , ))
expect_equal(or3s(logi_wd, , ),
bor3(logi_wd, , ))
expect_equal(or3s(logi_we, , ),
bor3(logi_we, , ))
expect_equal(or3s(logi_wf, , n %between% c(-1L, 1L)),
bor3(logi_wf, , n %between% c(-1L, 1L)))
expect_equal(or3s(logi_wg, , i %between% c(-1L, 1L)),
bor3(logi_wg, , i %between% c(-1L, 1L)))
expect_equal(or3s(logi_wh, , b %between% c(-1L, 1L)),
bor3(logi_wh, , b %between% c(-1L, 1L)))
expect_equal(or3s(logi_wi, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_wi, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_wj, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_wj, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_wk, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_wk, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_wl, l %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L)),
bor3(logi_wl, l %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L)))
expect_equal(or3s(logi_wm, x %in% c(4L, -3L, 2L, 7L, 8L), w %between% c(-1L, 1L)),
bor3(logi_wm, x %in% c(4L, -3L, 2L, 7L, 8L), w %between% c(-1L, 1L)))
expect_equal(or3s(logi_wn, m %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L)),
bor3(logi_wn, m %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L)))
expect_equal(or3s(logi_wo, , ),
bor3(logi_wo, , ))
expect_equal(or3s(logi_wp, , ),
bor3(logi_wp, , ))
expect_equal(or3s(logi_wq, , ),
bor3(logi_wq, , ))
expect_equal(or3s(logi_wr, , d %between% c(-1L, 1L)),
bor3(logi_wr, , d %between% c(-1L, 1L)))
expect_equal(or3s(logi_ws, , d %between% c(-1L, 1L)),
bor3(logi_ws, , d %between% c(-1L, 1L)))
expect_equal(or3s(logi_wt, , g %between% c(-1L, 1L)),
bor3(logi_wt, , g %between% c(-1L, 1L)))
expect_equal(or3s(logi_wu, z %in% 1:4, ),
bor3(logi_wu, z %in% 1:4, ))
expect_equal(or3s(logi_wv, t %in% 1:4, ),
bor3(logi_wv, t %in% 1:4, ))
expect_equal(or3s(logi_ww, r %in% 1:4, ),
bor3(logi_ww, r %in% 1:4, ))
expect_equal(or3s(logi_wx, s %in% 1:4, j %between% c(-1L, 1L)),
bor3(logi_wx, s %in% 1:4, j %between% c(-1L, 1L)))
expect_equal(or3s(logi_wy, u %in% 1:4, q %between% c(-1L, 1L)),
bor3(logi_wy, u %in% 1:4, q %between% c(-1L, 1L)))
expect_equal(or3s(logi_wz, d %in% 1:4, j %between% c(-1L, 1L)),
bor3(logi_wz, d %in% 1:4, j %between% c(-1L, 1L)))
expect_equal(or3s(logi_xa, , ),
bor3(logi_xa, , ))
expect_equal(or3s(logi_xb, , ),
bor3(logi_xb, , ))
expect_equal(or3s(logi_xc, , ),
bor3(logi_xc, , ))
expect_equal(or3s(logi_xd, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_xd, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_xe, , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_xe, , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_xf, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_xf, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_xg, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_xg, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_xh, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_xh, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_xi, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_xi, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_xj, o %in% c(4L, -3L, 2L, 7L, 8L), h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_xj, o %in% c(4L, -3L, 2L, 7L, 8L), h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_xk, b %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_xk, b %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_xl, e %in% c(4L, -3L, 2L, 7L, 8L), s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_xl, e %in% c(4L, -3L, 2L, 7L, 8L), s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_xm, , ),
bor3(logi_xm, , ))
expect_equal(or3s(logi_xn, , ),
bor3(logi_xn, , ))
expect_equal(or3s(logi_xo, , ),
bor3(logi_xo, , ))
expect_equal(or3s(logi_xp, , c %in% 1:4),
bor3(logi_xp, , c %in% 1:4))
expect_equal(or3s(logi_xq, , x %in% 1:4),
bor3(logi_xq, , x %in% 1:4))
expect_equal(or3s(logi_xr, , f %in% 1:4),
bor3(logi_xr, , f %in% 1:4))
expect_equal(or3s(logi_xs, j %in% 1:4, ),
bor3(logi_xs, j %in% 1:4, ))
expect_equal(or3s(logi_xt, v %in% 1:4, ),
bor3(logi_xt, v %in% 1:4, ))
expect_equal(or3s(logi_xu, d %in% 1:4, ),
bor3(logi_xu, d %in% 1:4, ))
expect_equal(or3s(logi_xv, f %in% 1:4, c %in% 1:4),
bor3(logi_xv, f %in% 1:4, c %in% 1:4))
expect_equal(or3s(logi_xw, w %in% 1:4, j %in% 1:4),
bor3(logi_xw, w %in% 1:4, j %in% 1:4))
expect_equal(or3s(logi_xx, o %in% 1:4, n %in% 1:4),
bor3(logi_xx, o %in% 1:4, n %in% 1:4))
expect_equal(or3s(logi_xy, , ),
bor3(logi_xy, , ))
expect_equal(or3s(logi_xz, , ),
bor3(logi_xz, , ))
expect_equal(or3s(logi_ya, , ),
bor3(logi_ya, , ))
expect_equal(or3s(logi_yb, , s < 0L),
bor3(logi_yb, , s < 0L))
expect_equal(or3s(logi_yc, , e < 1L),
bor3(logi_yc, , e < 1L))
expect_equal(or3s(logi_yd, , d < 9L),
bor3(logi_yd, , d < 9L))
expect_equal(or3s(logi_ye, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_ye, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_yf, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_yf, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_yg, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_yg, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_yh, e %in% c(4L, -3L, 2L, 7L, 8L), h < 0L),
bor3(logi_yh, e %in% c(4L, -3L, 2L, 7L, 8L), h < 0L))
expect_equal(or3s(logi_yi, g %in% c(4L, -3L, 2L, 7L, 8L), p < 1L),
bor3(logi_yi, g %in% c(4L, -3L, 2L, 7L, 8L), p < 1L))
expect_equal(or3s(logi_yj, e %in% c(4L, -3L, 2L, 7L, 8L), o < 9L),
bor3(logi_yj, e %in% c(4L, -3L, 2L, 7L, 8L), o < 9L))
expect_equal(or3s(logi_yk, , ),
bor3(logi_yk, , ))
expect_equal(or3s(logi_yl, , ),
bor3(logi_yl, , ))
expect_equal(or3s(logi_ym, , ),
bor3(logi_ym, , ))
expect_equal(or3s(logi_yn, , j < 0L),
bor3(logi_yn, , j < 0L))
expect_equal(or3s(logi_yo, , t < 1L),
bor3(logi_yo, , t < 1L))
expect_equal(or3s(logi_yp, , m < 9L),
bor3(logi_yp, , m < 9L))
expect_equal(or3s(logi_yq, m %in% 1:4, ),
bor3(logi_yq, m %in% 1:4, ))
expect_equal(or3s(logi_yr, q %in% 1:4, ),
bor3(logi_yr, q %in% 1:4, ))
expect_equal(or3s(logi_ys, d %in% 1:4, ),
bor3(logi_ys, d %in% 1:4, ))
expect_equal(or3s(logi_yt, w %in% 1:4, a < 0L),
bor3(logi_yt, w %in% 1:4, a < 0L))
expect_equal(or3s(logi_yu, k %in% 1:4, d < 1L),
bor3(logi_yu, k %in% 1:4, d < 1L))
expect_equal(or3s(logi_yv, p %in% 1:4, l < 9L),
bor3(logi_yv, p %in% 1:4, l < 9L))
expect_equal(or3s(logi_yw, , ),
bor3(logi_yw, , ))
expect_equal(or3s(logi_yx, , ),
bor3(logi_yx, , ))
expect_equal(or3s(logi_yy, , ),
bor3(logi_yy, , ))
expect_equal(or3s(logi_yz, , a <= 0L),
bor3(logi_yz, , a <= 0L))
expect_equal(or3s(logi_aa, , b <= 1L),
bor3(logi_aa, , b <= 1L))
expect_equal(or3s(logi_ab, , i <= 9L),
bor3(logi_ab, , i <= 9L))
expect_equal(or3s(logi_ac, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_ac, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_ad, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_ad, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_ae, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_ae, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_af, f %in% c(4L, -3L, 2L, 7L, 8L), x <= 0L),
bor3(logi_af, f %in% c(4L, -3L, 2L, 7L, 8L), x <= 0L))
expect_equal(or3s(logi_ag, q %in% c(4L, -3L, 2L, 7L, 8L), a <= 1L),
bor3(logi_ag, q %in% c(4L, -3L, 2L, 7L, 8L), a <= 1L))
expect_equal(or3s(logi_ah, j %in% c(4L, -3L, 2L, 7L, 8L), d <= 9L),
bor3(logi_ah, j %in% c(4L, -3L, 2L, 7L, 8L), d <= 9L))
expect_equal(or3s(logi_ai, , ),
bor3(logi_ai, , ))
expect_equal(or3s(logi_aj, , ),
bor3(logi_aj, , ))
expect_equal(or3s(logi_ak, , ),
bor3(logi_ak, , ))
expect_equal(or3s(logi_al, , a <= 0L),
bor3(logi_al, , a <= 0L))
expect_equal(or3s(logi_am, , l <= 1L),
bor3(logi_am, , l <= 1L))
expect_equal(or3s(logi_an, , w <= 9L),
bor3(logi_an, , w <= 9L))
expect_equal(or3s(logi_ao, w %in% 1:4, ),
bor3(logi_ao, w %in% 1:4, ))
expect_equal(or3s(logi_ap, f %in% 1:4, ),
bor3(logi_ap, f %in% 1:4, ))
expect_equal(or3s(logi_aq, w %in% 1:4, ),
bor3(logi_aq, w %in% 1:4, ))
expect_equal(or3s(logi_ar, w %in% 1:4, z <= 0L),
bor3(logi_ar, w %in% 1:4, z <= 0L))
expect_equal(or3s(logi_as, b %in% 1:4, a <= 1L),
bor3(logi_as, b %in% 1:4, a <= 1L))
expect_equal(or3s(logi_at, f %in% 1:4, f <= 9L),
bor3(logi_at, f %in% 1:4, f <= 9L))
expect_equal(or3s(logi_au, , ),
bor3(logi_au, , ))
expect_equal(or3s(logi_av, , ),
bor3(logi_av, , ))
expect_equal(or3s(logi_aw, , ),
bor3(logi_aw, , ))
expect_equal(or3s(logi_ax, , b == 0L),
bor3(logi_ax, , b == 0L))
expect_equal(or3s(logi_ay, , a == 1L),
bor3(logi_ay, , a == 1L))
expect_equal(or3s(logi_az, , g == 9L),
bor3(logi_az, , g == 9L))
expect_equal(or3s(logi_aaa, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aaa, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_aab, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aab, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_aac, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aac, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_aad, h %in% c(4L, -3L, 2L, 7L, 8L), i == 0L),
bor3(logi_aad, h %in% c(4L, -3L, 2L, 7L, 8L), i == 0L))
expect_equal(or3s(logi_aae, b %in% c(4L, -3L, 2L, 7L, 8L), s == 1L),
bor3(logi_aae, b %in% c(4L, -3L, 2L, 7L, 8L), s == 1L))
expect_equal(or3s(logi_aaf, e %in% c(4L, -3L, 2L, 7L, 8L), k == 9L),
bor3(logi_aaf, e %in% c(4L, -3L, 2L, 7L, 8L), k == 9L))
expect_equal(or3s(logi_aag, , ),
bor3(logi_aag, , ))
expect_equal(or3s(logi_aah, , ),
bor3(logi_aah, , ))
expect_equal(or3s(logi_aai, , ),
bor3(logi_aai, , ))
expect_equal(or3s(logi_aaj, , g == 0L),
bor3(logi_aaj, , g == 0L))
expect_equal(or3s(logi_aak, , u == 1L),
bor3(logi_aak, , u == 1L))
expect_equal(or3s(logi_aal, , q == 9L),
bor3(logi_aal, , q == 9L))
expect_equal(or3s(logi_aam, w %in% 1:4, ),
bor3(logi_aam, w %in% 1:4, ))
expect_equal(or3s(logi_aan, w %in% 1:4, ),
bor3(logi_aan, w %in% 1:4, ))
expect_equal(or3s(logi_aao, r %in% 1:4, ),
bor3(logi_aao, r %in% 1:4, ))
expect_equal(or3s(logi_aap, b %in% 1:4, b == 0L),
bor3(logi_aap, b %in% 1:4, b == 0L))
expect_equal(or3s(logi_aaq, u %in% 1:4, x == 1L),
bor3(logi_aaq, u %in% 1:4, x == 1L))
expect_equal(or3s(logi_aar, d %in% 1:4, p == 9L),
bor3(logi_aar, d %in% 1:4, p == 9L))
expect_equal(or3s(logi_aas, , ),
bor3(logi_aas, , ))
expect_equal(or3s(logi_aat, , ),
bor3(logi_aat, , ))
expect_equal(or3s(logi_aau, , ),
bor3(logi_aau, , ))
expect_equal(or3s(logi_aav, , y > 0L),
bor3(logi_aav, , y > 0L))
expect_equal(or3s(logi_aaw, , b > 1L),
bor3(logi_aaw, , b > 1L))
expect_equal(or3s(logi_aax, , b > 9L),
bor3(logi_aax, , b > 9L))
expect_equal(or3s(logi_aay, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aay, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_aaz, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aaz, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_aba, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aba, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_abb, s %in% c(4L, -3L, 2L, 7L, 8L), i > 0L),
bor3(logi_abb, s %in% c(4L, -3L, 2L, 7L, 8L), i > 0L))
expect_equal(or3s(logi_abc, o %in% c(4L, -3L, 2L, 7L, 8L), x > 1L),
bor3(logi_abc, o %in% c(4L, -3L, 2L, 7L, 8L), x > 1L))
expect_equal(or3s(logi_abd, y %in% c(4L, -3L, 2L, 7L, 8L), k > 9L),
bor3(logi_abd, y %in% c(4L, -3L, 2L, 7L, 8L), k > 9L))
expect_equal(or3s(logi_abe, , ),
bor3(logi_abe, , ))
expect_equal(or3s(logi_abf, , ),
bor3(logi_abf, , ))
expect_equal(or3s(logi_abg, , ),
bor3(logi_abg, , ))
expect_equal(or3s(logi_abh, , w > 0L),
bor3(logi_abh, , w > 0L))
expect_equal(or3s(logi_abi, , h > 1L),
bor3(logi_abi, , h > 1L))
expect_equal(or3s(logi_abj, , x > 9L),
bor3(logi_abj, , x > 9L))
expect_equal(or3s(logi_abk, j %in% 1:4, ),
bor3(logi_abk, j %in% 1:4, ))
expect_equal(or3s(logi_abl, f %in% 1:4, ),
bor3(logi_abl, f %in% 1:4, ))
expect_equal(or3s(logi_abm, j %in% 1:4, ),
bor3(logi_abm, j %in% 1:4, ))
expect_equal(or3s(logi_abn, d %in% 1:4, i > 0L),
bor3(logi_abn, d %in% 1:4, i > 0L))
expect_equal(or3s(logi_abo, f %in% 1:4, r > 1L),
bor3(logi_abo, f %in% 1:4, r > 1L))
expect_equal(or3s(logi_abp, i %in% 1:4, k > 9L),
bor3(logi_abp, i %in% 1:4, k > 9L))
expect_equal(or3s(logi_abq, , ),
bor3(logi_abq, , ))
expect_equal(or3s(logi_abr, , ),
bor3(logi_abr, , ))
expect_equal(or3s(logi_abs, , ),
bor3(logi_abs, , ))
expect_equal(or3s(logi_abt, , p >= 0L),
bor3(logi_abt, , p >= 0L))
expect_equal(or3s(logi_abu, , u >= 1L),
bor3(logi_abu, , u >= 1L))
expect_equal(or3s(logi_abv, , x >= 9L),
bor3(logi_abv, , x >= 9L))
expect_equal(or3s(logi_abw, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_abw, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_abx, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_abx, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_aby, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(logi_aby, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(logi_abz, v %in% c(4L, -3L, 2L, 7L, 8L), a >= 0L),
bor3(logi_abz, v %in% c(4L, -3L, 2L, 7L, 8L), a >= 0L))
expect_equal(or3s(logi_aca, r %in% c(4L, -3L, 2L, 7L, 8L), l >= 1L),
bor3(logi_aca, r %in% c(4L, -3L, 2L, 7L, 8L), l >= 1L))
expect_equal(or3s(logi_acb, x %in% c(4L, -3L, 2L, 7L, 8L), i >= 9L),
bor3(logi_acb, x %in% c(4L, -3L, 2L, 7L, 8L), i >= 9L))
expect_equal(or3s(logi_acc, , ),
bor3(logi_acc, , ))
expect_equal(or3s(logi_acd, , ),
bor3(logi_acd, , ))
expect_equal(or3s(logi_ace, , ),
bor3(logi_ace, , ))
expect_equal(or3s(logi_acf, , a >= 0L),
bor3(logi_acf, , a >= 0L))
expect_equal(or3s(logi_acg, , e >= 1L),
bor3(logi_acg, , e >= 1L))
expect_equal(or3s(logi_ach, , r >= 9L),
bor3(logi_ach, , r >= 9L))
expect_equal(or3s(logi_aci, n %in% 1:4, ),
bor3(logi_aci, n %in% 1:4, ))
expect_equal(or3s(logi_acj, p %in% 1:4, ),
bor3(logi_acj, p %in% 1:4, ))
expect_equal(or3s(logi_ack, m %in% 1:4, ),
bor3(logi_ack, m %in% 1:4, ))
expect_equal(or3s(logi_acl, e %in% 1:4, c >= 0L),
bor3(logi_acl, e %in% 1:4, c >= 0L))
expect_equal(or3s(logi_acm, d %in% 1:4, a >= 1L),
bor3(logi_acm, d %in% 1:4, a >= 1L))
expect_equal(or3s(logi_acn, h %in% 1:4, c >= 9L),
bor3(logi_acn, h %in% 1:4, c >= 9L))
expect_equal(or3s(logi_aco, , ),
bor3(logi_aco, , ))
expect_equal(or3s(logi_acp, , ),
bor3(logi_acp, , ))
expect_equal(or3s(logi_acq, , ),
bor3(logi_acq, , ))
expect_equal(or3s(logi_acr, , logi_w),
bor3(logi_acr, , logi_w))
expect_equal(or3s(logi_acs, , logi_f),
bor3(logi_acs, , logi_f))
expect_equal(or3s(logi_act, , logi_y),
bor3(logi_act, , logi_y))
expect_equal(or3s(logi_acu, h < 0L, ),
bor3(logi_acu, h < 0L, ))
expect_equal(or3s(logi_acv, n < 1L, ),
bor3(logi_acv, n < 1L, ))
expect_equal(or3s(logi_acw, w < 9L, ),
bor3(logi_acw, w < 9L, ))
expect_equal(or3s(logi_acx, o < 0L, logi_b),
bor3(logi_acx, o < 0L, logi_b))
expect_equal(or3s(logi_acy, l < 1L, logi_b),
bor3(logi_acy, l < 1L, logi_b))
expect_equal(or3s(logi_acz, s < 9L, logi_g),
bor3(logi_acz, s < 9L, logi_g))
expect_equal(or3s(logi_ada, , ),
bor3(logi_ada, , ))
expect_equal(or3s(logi_adb, , ),
bor3(logi_adb, , ))
expect_equal(or3s(logi_adc, , ),
bor3(logi_adc, , ))
expect_equal(or3s(logi_add, , !logi_r),
bor3(logi_add, , !logi_r))
expect_equal(or3s(logi_ade, , !logi_e),
bor3(logi_ade, , !logi_e))
expect_equal(or3s(logi_adf, , !logi_g),
bor3(logi_adf, , !logi_g))
expect_equal(or3s(logi_adg, d < 0L, ),
bor3(logi_adg, d < 0L, ))
expect_equal(or3s(logi_adh, v < 1L, ),
bor3(logi_adh, v < 1L, ))
expect_equal(or3s(logi_adi, q < 9L, ),
bor3(logi_adi, q < 9L, ))
expect_equal(or3s(logi_adj, n < 0L, !logi_x),
bor3(logi_adj, n < 0L, !logi_x))
expect_equal(or3s(logi_adk, z < 1L, !logi_i),
bor3(logi_adk, z < 1L, !logi_i))
expect_equal(or3s(logi_adl, m < 9L, !logi_o),
bor3(logi_adl, m < 9L, !logi_o))
expect_equal(or3s(logi_adm, , ),
bor3(logi_adm, , ))
expect_equal(or3s(logi_adn, , ),
bor3(logi_adn, , ))
expect_equal(or3s(logi_ado, , ),
bor3(logi_ado, , ))
expect_equal(or3s(logi_adp, , e != 0L),
bor3(logi_adp, , e != 0L))
expect_equal(or3s(logi_adq, , z != 1L),
bor3(logi_adq, , z != 1L))
expect_equal(or3s(logi_adr, , u != 9L),
bor3(logi_adr, , u != 9L))
expect_equal(or3s(logi_ads, b < 0L, ),
bor3(logi_ads, b < 0L, ))
expect_equal(or3s(logi_adt, m < 1L, ),
bor3(logi_adt, m < 1L, ))
expect_equal(or3s(logi_adu, y < 9L, ),
bor3(logi_adu, y < 9L, ))
expect_equal(or3s(logi_adv, x < 0L, y != 0L),
bor3(logi_adv, x < 0L, y != 0L))
expect_equal(or3s(logi_adw, h < 1L, k != 1L),
bor3(logi_adw, h < 1L, k != 1L))
expect_equal(or3s(logi_adx, a < 9L, k != 9L),
bor3(logi_adx, a < 9L, k != 9L))
expect_equal(or3s(logi_ady, , ),
bor3(logi_ady, , ))
expect_equal(or3s(logi_adz, , ),
bor3(logi_adz, , ))
expect_equal(or3s(logi_aea, , ),
bor3(logi_aea, , ))
expect_equal(or3s(logi_aeb, , g %between% c(-1L, 1L)),
bor3(logi_aeb, , g %between% c(-1L, 1L)))
expect_equal(or3s(logi_aec, , a %between% c(-1L, 1L)),
bor3(logi_aec, , a %between% c(-1L, 1L)))
expect_equal(or3s(logi_aed, , u %between% c(-1L, 1L)),
bor3(logi_aed, , u %between% c(-1L, 1L)))
expect_equal(or3s(logi_aee, z < 0L, ),
bor3(logi_aee, z < 0L, ))
expect_equal(or3s(logi_aef, q < 1L, ),
bor3(logi_aef, q < 1L, ))
expect_equal(or3s(logi_aeg, x < 9L, ),
bor3(logi_aeg, x < 9L, ))
expect_equal(or3s(logi_aeh, d < 0L, x %between% c(-1L, 1L)),
bor3(logi_aeh, d < 0L, x %between% c(-1L, 1L)))
expect_equal(or3s(logi_aei, l < 1L, b %between% c(-1L, 1L)),
bor3(logi_aei, l < 1L, b %between% c(-1L, 1L)))
expect_equal(or3s(logi_aej, i < 9L, k %between% c(-1L, 1L)),
bor3(logi_aej, i < 9L, k %between% c(-1L, 1L)))
expect_equal(or3s(logi_aek, , ),
bor3(logi_aek, , ))
expect_equal(or3s(logi_ael, , ),
bor3(logi_ael, , ))
expect_equal(or3s(logi_aem, , ),
bor3(logi_aem, , ))
expect_equal(or3s(logi_aen, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aen, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aeo, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aeo, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aep, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aep, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aeq, e < 0L, ),
bor3(logi_aeq, e < 0L, ))
expect_equal(or3s(logi_aer, d < 1L, ),
bor3(logi_aer, d < 1L, ))
expect_equal(or3s(logi_aes, i < 9L, ),
bor3(logi_aes, i < 9L, ))
expect_equal(or3s(logi_aet, z < 0L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aet, z < 0L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aeu, m < 1L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aeu, m < 1L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aev, q < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aev, q < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aew, , ),
bor3(logi_aew, , ))
expect_equal(or3s(logi_aex, , ),
bor3(logi_aex, , ))
expect_equal(or3s(logi_aey, , ),
bor3(logi_aey, , ))
expect_equal(or3s(logi_aez, , s %in% 1:4),
bor3(logi_aez, , s %in% 1:4))
expect_equal(or3s(logi_afa, , e %in% 1:4),
bor3(logi_afa, , e %in% 1:4))
expect_equal(or3s(logi_afb, , p %in% 1:4),
bor3(logi_afb, , p %in% 1:4))
expect_equal(or3s(logi_afc, a < 0L, ),
bor3(logi_afc, a < 0L, ))
expect_equal(or3s(logi_afd, u < 1L, ),
bor3(logi_afd, u < 1L, ))
expect_equal(or3s(logi_afe, z < 9L, ),
bor3(logi_afe, z < 9L, ))
expect_equal(or3s(logi_aff, d < 0L, d %in% 1:4),
bor3(logi_aff, d < 0L, d %in% 1:4))
expect_equal(or3s(logi_afg, a < 1L, b %in% 1:4),
bor3(logi_afg, a < 1L, b %in% 1:4))
expect_equal(or3s(logi_afh, y < 9L, q %in% 1:4),
bor3(logi_afh, y < 9L, q %in% 1:4))
expect_equal(or3s(logi_afi, , ),
bor3(logi_afi, , ))
expect_equal(or3s(logi_afj, , ),
bor3(logi_afj, , ))
expect_equal(or3s(logi_afk, , ),
bor3(logi_afk, , ))
expect_equal(or3s(logi_afl, , q < 0L),
bor3(logi_afl, , q < 0L))
expect_equal(or3s(logi_afm, , k < 1L),
bor3(logi_afm, , k < 1L))
expect_equal(or3s(logi_afn, , f < 9L),
bor3(logi_afn, , f < 9L))
expect_equal(or3s(logi_afo, y < 0L, ),
bor3(logi_afo, y < 0L, ))
expect_equal(or3s(logi_afp, j < 1L, ),
bor3(logi_afp, j < 1L, ))
expect_equal(or3s(logi_afq, l < 9L, ),
bor3(logi_afq, l < 9L, ))
expect_equal(or3s(logi_afr, e < 0L, y < 0L),
bor3(logi_afr, e < 0L, y < 0L))
expect_equal(or3s(logi_afs, w < 1L, x < 1L),
bor3(logi_afs, w < 1L, x < 1L))
expect_equal(or3s(logi_aft, y < 9L, c < 9L),
bor3(logi_aft, y < 9L, c < 9L))
expect_equal(or3s(logi_afu, , ),
bor3(logi_afu, , ))
expect_equal(or3s(logi_afv, , ),
bor3(logi_afv, , ))
expect_equal(or3s(logi_afw, , ),
bor3(logi_afw, , ))
expect_equal(or3s(logi_afx, , o <= 0L),
bor3(logi_afx, , o <= 0L))
expect_equal(or3s(logi_afy, , r <= 1L),
bor3(logi_afy, , r <= 1L))
expect_equal(or3s(logi_afz, , p <= 9L),
bor3(logi_afz, , p <= 9L))
expect_equal(or3s(logi_aga, g < 0L, ),
bor3(logi_aga, g < 0L, ))
expect_equal(or3s(logi_agb, u < 1L, ),
bor3(logi_agb, u < 1L, ))
expect_equal(or3s(logi_agc, i < 9L, ),
bor3(logi_agc, i < 9L, ))
expect_equal(or3s(logi_agd, e < 0L, d <= 0L),
bor3(logi_agd, e < 0L, d <= 0L))
expect_equal(or3s(logi_age, m < 1L, i <= 1L),
bor3(logi_age, m < 1L, i <= 1L))
expect_equal(or3s(logi_agf, x < 9L, h <= 9L),
bor3(logi_agf, x < 9L, h <= 9L))
expect_equal(or3s(logi_agg, , ),
bor3(logi_agg, , ))
expect_equal(or3s(logi_agh, , ),
bor3(logi_agh, , ))
expect_equal(or3s(logi_agi, , ),
bor3(logi_agi, , ))
expect_equal(or3s(logi_agj, , z == 0L),
bor3(logi_agj, , z == 0L))
expect_equal(or3s(logi_agk, , i == 1L),
bor3(logi_agk, , i == 1L))
expect_equal(or3s(logi_agl, , o == 9L),
bor3(logi_agl, , o == 9L))
expect_equal(or3s(logi_agm, h < 0L, ),
bor3(logi_agm, h < 0L, ))
expect_equal(or3s(logi_agn, q < 1L, ),
bor3(logi_agn, q < 1L, ))
expect_equal(or3s(logi_ago, j < 9L, ),
bor3(logi_ago, j < 9L, ))
expect_equal(or3s(logi_agp, i < 0L, u == 0L),
bor3(logi_agp, i < 0L, u == 0L))
expect_equal(or3s(logi_agq, x < 1L, e == 1L),
bor3(logi_agq, x < 1L, e == 1L))
expect_equal(or3s(logi_agr, j < 9L, w == 9L),
bor3(logi_agr, j < 9L, w == 9L))
expect_equal(or3s(logi_ags, , ),
bor3(logi_ags, , ))
expect_equal(or3s(logi_agt, , ),
bor3(logi_agt, , ))
expect_equal(or3s(logi_agu, , ),
bor3(logi_agu, , ))
expect_equal(or3s(logi_agv, , w > 0L),
bor3(logi_agv, , w > 0L))
expect_equal(or3s(logi_agw, , k > 1L),
bor3(logi_agw, , k > 1L))
expect_equal(or3s(logi_agx, , n > 9L),
bor3(logi_agx, , n > 9L))
expect_equal(or3s(logi_agy, j < 0L, ),
bor3(logi_agy, j < 0L, ))
expect_equal(or3s(logi_agz, z < 1L, ),
bor3(logi_agz, z < 1L, ))
expect_equal(or3s(logi_aha, e < 9L, ),
bor3(logi_aha, e < 9L, ))
expect_equal(or3s(logi_ahb, k < 0L, j > 0L),
bor3(logi_ahb, k < 0L, j > 0L))
expect_equal(or3s(logi_ahc, m < 1L, f > 1L),
bor3(logi_ahc, m < 1L, f > 1L))
expect_equal(or3s(logi_ahd, g < 9L, l > 9L),
bor3(logi_ahd, g < 9L, l > 9L))
expect_equal(or3s(logi_ahe, , ),
bor3(logi_ahe, , ))
expect_equal(or3s(logi_ahf, , ),
bor3(logi_ahf, , ))
expect_equal(or3s(logi_ahg, , ),
bor3(logi_ahg, , ))
expect_equal(or3s(logi_ahh, , z >= 0L),
bor3(logi_ahh, , z >= 0L))
expect_equal(or3s(logi_ahi, , y >= 1L),
bor3(logi_ahi, , y >= 1L))
expect_equal(or3s(logi_ahj, , j >= 9L),
bor3(logi_ahj, , j >= 9L))
expect_equal(or3s(logi_ahk, w < 0L, ),
bor3(logi_ahk, w < 0L, ))
expect_equal(or3s(logi_ahl, e < 1L, ),
bor3(logi_ahl, e < 1L, ))
expect_equal(or3s(logi_ahm, p < 9L, ),
bor3(logi_ahm, p < 9L, ))
expect_equal(or3s(logi_ahn, u < 0L, z >= 0L),
bor3(logi_ahn, u < 0L, z >= 0L))
expect_equal(or3s(logi_aho, z < 1L, y >= 1L),
bor3(logi_aho, z < 1L, y >= 1L))
expect_equal(or3s(logi_ahp, u < 9L, t >= 9L),
bor3(logi_ahp, u < 9L, t >= 9L))
expect_equal(or3s(logi_ahq, , ),
bor3(logi_ahq, , ))
expect_equal(or3s(logi_ahr, , ),
bor3(logi_ahr, , ))
expect_equal(or3s(logi_ahs, , ),
bor3(logi_ahs, , ))
expect_equal(or3s(logi_aht, , logi_c),
bor3(logi_aht, , logi_c))
expect_equal(or3s(logi_ahu, , logi_c),
bor3(logi_ahu, , logi_c))
expect_equal(or3s(logi_ahv, , logi_u),
bor3(logi_ahv, , logi_u))
expect_equal(or3s(logi_ahw, i <= 0L, ),
bor3(logi_ahw, i <= 0L, ))
expect_equal(or3s(logi_ahx, q <= 1L, ),
bor3(logi_ahx, q <= 1L, ))
expect_equal(or3s(logi_ahy, n <= 9L, ),
bor3(logi_ahy, n <= 9L, ))
expect_equal(or3s(logi_ahz, p <= 0L, logi_q),
bor3(logi_ahz, p <= 0L, logi_q))
expect_equal(or3s(logi_aia, n <= 1L, logi_d),
bor3(logi_aia, n <= 1L, logi_d))
expect_equal(or3s(logi_aib, w <= 9L, logi_c),
bor3(logi_aib, w <= 9L, logi_c))
expect_equal(or3s(logi_aic, , ),
bor3(logi_aic, , ))
expect_equal(or3s(logi_aid, , ),
bor3(logi_aid, , ))
expect_equal(or3s(logi_aie, , ),
bor3(logi_aie, , ))
expect_equal(or3s(logi_aif, , !logi_k),
bor3(logi_aif, , !logi_k))
expect_equal(or3s(logi_aig, , !logi_c),
bor3(logi_aig, , !logi_c))
expect_equal(or3s(logi_aih, , !logi_l),
bor3(logi_aih, , !logi_l))
expect_equal(or3s(logi_aii, e <= 0L, ),
bor3(logi_aii, e <= 0L, ))
expect_equal(or3s(logi_aij, a <= 1L, ),
bor3(logi_aij, a <= 1L, ))
expect_equal(or3s(logi_aik, d <= 9L, ),
bor3(logi_aik, d <= 9L, ))
expect_equal(or3s(logi_ail, t <= 0L, !logi_q),
bor3(logi_ail, t <= 0L, !logi_q))
expect_equal(or3s(logi_aim, g <= 1L, !logi_p),
bor3(logi_aim, g <= 1L, !logi_p))
expect_equal(or3s(logi_ain, f <= 9L, !logi_w),
bor3(logi_ain, f <= 9L, !logi_w))
expect_equal(or3s(logi_aio, , ),
bor3(logi_aio, , ))
expect_equal(or3s(logi_aip, , ),
bor3(logi_aip, , ))
expect_equal(or3s(logi_aiq, , ),
bor3(logi_aiq, , ))
expect_equal(or3s(logi_air, , n != 0L),
bor3(logi_air, , n != 0L))
expect_equal(or3s(logi_ais, , s != 1L),
bor3(logi_ais, , s != 1L))
expect_equal(or3s(logi_ait, , p != 9L),
bor3(logi_ait, , p != 9L))
expect_equal(or3s(logi_aiu, h <= 0L, ),
bor3(logi_aiu, h <= 0L, ))
expect_equal(or3s(logi_aiv, d <= 1L, ),
bor3(logi_aiv, d <= 1L, ))
expect_equal(or3s(logi_aiw, w <= 9L, ),
bor3(logi_aiw, w <= 9L, ))
expect_equal(or3s(logi_aix, r <= 0L, h != 0L),
bor3(logi_aix, r <= 0L, h != 0L))
expect_equal(or3s(logi_aiy, g <= 1L, u != 1L),
bor3(logi_aiy, g <= 1L, u != 1L))
expect_equal(or3s(logi_aiz, p <= 9L, v != 9L),
bor3(logi_aiz, p <= 9L, v != 9L))
expect_equal(or3s(logi_aja, , ),
bor3(logi_aja, , ))
expect_equal(or3s(logi_ajb, , ),
bor3(logi_ajb, , ))
expect_equal(or3s(logi_ajc, , ),
bor3(logi_ajc, , ))
expect_equal(or3s(logi_ajd, , w %between% c(-1L, 1L)),
bor3(logi_ajd, , w %between% c(-1L, 1L)))
expect_equal(or3s(logi_aje, , z %between% c(-1L, 1L)),
bor3(logi_aje, , z %between% c(-1L, 1L)))
expect_equal(or3s(logi_ajf, , q %between% c(-1L, 1L)),
bor3(logi_ajf, , q %between% c(-1L, 1L)))
expect_equal(or3s(logi_ajg, v <= 0L, ),
bor3(logi_ajg, v <= 0L, ))
expect_equal(or3s(logi_ajh, i <= 1L, ),
bor3(logi_ajh, i <= 1L, ))
expect_equal(or3s(logi_aji, n <= 9L, ),
bor3(logi_aji, n <= 9L, ))
expect_equal(or3s(logi_ajj, q <= 0L, i %between% c(-1L, 1L)),
bor3(logi_ajj, q <= 0L, i %between% c(-1L, 1L)))
expect_equal(or3s(logi_ajk, d <= 1L, s %between% c(-1L, 1L)),
bor3(logi_ajk, d <= 1L, s %between% c(-1L, 1L)))
expect_equal(or3s(logi_ajl, p <= 9L, f %between% c(-1L, 1L)),
bor3(logi_ajl, p <= 9L, f %between% c(-1L, 1L)))
expect_equal(or3s(logi_ajm, , ),
bor3(logi_ajm, , ))
expect_equal(or3s(logi_ajn, , ),
bor3(logi_ajn, , ))
expect_equal(or3s(logi_ajo, , ),
bor3(logi_ajo, , ))
expect_equal(or3s(logi_ajp, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ajp, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ajq, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ajq, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ajr, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ajr, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ajs, v <= 0L, ),
bor3(logi_ajs, v <= 0L, ))
expect_equal(or3s(logi_ajt, t <= 1L, ),
bor3(logi_ajt, t <= 1L, ))
expect_equal(or3s(logi_aju, s <= 9L, ),
bor3(logi_aju, s <= 9L, ))
expect_equal(or3s(logi_ajv, n <= 0L, l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ajv, n <= 0L, l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ajw, a <= 1L, o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ajw, a <= 1L, o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ajx, i <= 9L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ajx, i <= 9L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ajy, , ),
bor3(logi_ajy, , ))
expect_equal(or3s(logi_ajz, , ),
bor3(logi_ajz, , ))
expect_equal(or3s(logi_aka, , ),
bor3(logi_aka, , ))
expect_equal(or3s(logi_akb, , t %in% 1:4),
bor3(logi_akb, , t %in% 1:4))
expect_equal(or3s(logi_akc, , g %in% 1:4),
bor3(logi_akc, , g %in% 1:4))
expect_equal(or3s(logi_akd, , d %in% 1:4),
bor3(logi_akd, , d %in% 1:4))
expect_equal(or3s(logi_ake, b <= 0L, ),
bor3(logi_ake, b <= 0L, ))
expect_equal(or3s(logi_akf, y <= 1L, ),
bor3(logi_akf, y <= 1L, ))
expect_equal(or3s(logi_akg, y <= 9L, ),
bor3(logi_akg, y <= 9L, ))
expect_equal(or3s(logi_akh, x <= 0L, r %in% 1:4),
bor3(logi_akh, x <= 0L, r %in% 1:4))
expect_equal(or3s(logi_aki, i <= 1L, a %in% 1:4),
bor3(logi_aki, i <= 1L, a %in% 1:4))
expect_equal(or3s(logi_akj, d <= 9L, n %in% 1:4),
bor3(logi_akj, d <= 9L, n %in% 1:4))
expect_equal(or3s(logi_akk, , ),
bor3(logi_akk, , ))
expect_equal(or3s(logi_akl, , ),
bor3(logi_akl, , ))
expect_equal(or3s(logi_akm, , ),
bor3(logi_akm, , ))
expect_equal(or3s(logi_akn, , p < 0L),
bor3(logi_akn, , p < 0L))
expect_equal(or3s(logi_ako, , w < 1L),
bor3(logi_ako, , w < 1L))
expect_equal(or3s(logi_akp, , t < 9L),
bor3(logi_akp, , t < 9L))
expect_equal(or3s(logi_akq, r <= 0L, ),
bor3(logi_akq, r <= 0L, ))
expect_equal(or3s(logi_akr, w <= 1L, ),
bor3(logi_akr, w <= 1L, ))
expect_equal(or3s(logi_aks, w <= 9L, ),
bor3(logi_aks, w <= 9L, ))
expect_equal(or3s(logi_akt, t <= 0L, j < 0L),
bor3(logi_akt, t <= 0L, j < 0L))
expect_equal(or3s(logi_aku, x <= 1L, b < 1L),
bor3(logi_aku, x <= 1L, b < 1L))
expect_equal(or3s(logi_akv, e <= 9L, v < 9L),
bor3(logi_akv, e <= 9L, v < 9L))
expect_equal(or3s(logi_akw, , ),
bor3(logi_akw, , ))
expect_equal(or3s(logi_akx, , ),
bor3(logi_akx, , ))
expect_equal(or3s(logi_aky, , ),
bor3(logi_aky, , ))
expect_equal(or3s(logi_akz, , r <= 0L),
bor3(logi_akz, , r <= 0L))
expect_equal(or3s(logi_ala, , o <= 1L),
bor3(logi_ala, , o <= 1L))
expect_equal(or3s(logi_alb, , d <= 9L),
bor3(logi_alb, , d <= 9L))
expect_equal(or3s(logi_alc, h <= 0L, ),
bor3(logi_alc, h <= 0L, ))
expect_equal(or3s(logi_ald, a <= 1L, ),
bor3(logi_ald, a <= 1L, ))
expect_equal(or3s(logi_ale, r <= 9L, ),
bor3(logi_ale, r <= 9L, ))
expect_equal(or3s(logi_alf, n <= 0L, b <= 0L),
bor3(logi_alf, n <= 0L, b <= 0L))
expect_equal(or3s(logi_alg, s <= 1L, u <= 1L),
bor3(logi_alg, s <= 1L, u <= 1L))
expect_equal(or3s(logi_alh, m <= 9L, e <= 9L),
bor3(logi_alh, m <= 9L, e <= 9L))
expect_equal(or3s(logi_ali, , ),
bor3(logi_ali, , ))
expect_equal(or3s(logi_alj, , ),
bor3(logi_alj, , ))
expect_equal(or3s(logi_alk, , ),
bor3(logi_alk, , ))
expect_equal(or3s(logi_all, , c == 0L),
bor3(logi_all, , c == 0L))
expect_equal(or3s(logi_alm, , u == 1L),
bor3(logi_alm, , u == 1L))
expect_equal(or3s(logi_aln, , k == 9L),
bor3(logi_aln, , k == 9L))
expect_equal(or3s(logi_alo, r <= 0L, ),
bor3(logi_alo, r <= 0L, ))
expect_equal(or3s(logi_alp, g <= 1L, ),
bor3(logi_alp, g <= 1L, ))
expect_equal(or3s(logi_alq, m <= 9L, ),
bor3(logi_alq, m <= 9L, ))
expect_equal(or3s(logi_alr, e <= 0L, x == 0L),
bor3(logi_alr, e <= 0L, x == 0L))
expect_equal(or3s(logi_als, r <= 1L, a == 1L),
bor3(logi_als, r <= 1L, a == 1L))
expect_equal(or3s(logi_alt, d <= 9L, h == 9L),
bor3(logi_alt, d <= 9L, h == 9L))
expect_equal(or3s(logi_alu, , ),
bor3(logi_alu, , ))
expect_equal(or3s(logi_alv, , ),
bor3(logi_alv, , ))
expect_equal(or3s(logi_alw, , ),
bor3(logi_alw, , ))
expect_equal(or3s(logi_alx, , h > 0L),
bor3(logi_alx, , h > 0L))
expect_equal(or3s(logi_aly, , q > 1L),
bor3(logi_aly, , q > 1L))
expect_equal(or3s(logi_alz, , c > 9L),
bor3(logi_alz, , c > 9L))
expect_equal(or3s(logi_ama, e <= 0L, ),
bor3(logi_ama, e <= 0L, ))
expect_equal(or3s(logi_amb, k <= 1L, ),
bor3(logi_amb, k <= 1L, ))
expect_equal(or3s(logi_amc, d <= 9L, ),
bor3(logi_amc, d <= 9L, ))
expect_equal(or3s(logi_amd, f <= 0L, z > 0L),
bor3(logi_amd, f <= 0L, z > 0L))
expect_equal(or3s(logi_ame, x <= 1L, u > 1L),
bor3(logi_ame, x <= 1L, u > 1L))
expect_equal(or3s(logi_amf, l <= 9L, b > 9L),
bor3(logi_amf, l <= 9L, b > 9L))
expect_equal(or3s(logi_amg, , ),
bor3(logi_amg, , ))
expect_equal(or3s(logi_amh, , ),
bor3(logi_amh, , ))
expect_equal(or3s(logi_ami, , ),
bor3(logi_ami, , ))
expect_equal(or3s(logi_amj, , q >= 0L),
bor3(logi_amj, , q >= 0L))
expect_equal(or3s(logi_amk, , a >= 1L),
bor3(logi_amk, , a >= 1L))
expect_equal(or3s(logi_aml, , p >= 9L),
bor3(logi_aml, , p >= 9L))
expect_equal(or3s(logi_amm, k <= 0L, ),
bor3(logi_amm, k <= 0L, ))
expect_equal(or3s(logi_amn, g <= 1L, ),
bor3(logi_amn, g <= 1L, ))
expect_equal(or3s(logi_amo, e <= 9L, ),
bor3(logi_amo, e <= 9L, ))
expect_equal(or3s(logi_amp, r <= 0L, e >= 0L),
bor3(logi_amp, r <= 0L, e >= 0L))
expect_equal(or3s(logi_amq, x <= 1L, y >= 1L),
bor3(logi_amq, x <= 1L, y >= 1L))
expect_equal(or3s(logi_amr, v <= 9L, u >= 9L),
bor3(logi_amr, v <= 9L, u >= 9L))
expect_equal(or3s(logi_ams, , ),
bor3(logi_ams, , ))
expect_equal(or3s(logi_amt, , ),
bor3(logi_amt, , ))
expect_equal(or3s(logi_amu, , ),
bor3(logi_amu, , ))
expect_equal(or3s(logi_amv, , logi_c),
bor3(logi_amv, , logi_c))
expect_equal(or3s(logi_amw, , logi_j),
bor3(logi_amw, , logi_j))
expect_equal(or3s(logi_amx, , logi_i),
bor3(logi_amx, , logi_i))
expect_equal(or3s(logi_amy, u == 0L, ),
bor3(logi_amy, u == 0L, ))
expect_equal(or3s(logi_amz, m == 1L, ),
bor3(logi_amz, m == 1L, ))
expect_equal(or3s(logi_ana, p == 9L, ),
bor3(logi_ana, p == 9L, ))
expect_equal(or3s(logi_anb, d == 0L, logi_t),
bor3(logi_anb, d == 0L, logi_t))
expect_equal(or3s(logi_anc, y == 1L, logi_r),
bor3(logi_anc, y == 1L, logi_r))
expect_equal(or3s(logi_and, p == 9L, logi_e),
bor3(logi_and, p == 9L, logi_e))
expect_equal(or3s(logi_ane, , ),
bor3(logi_ane, , ))
expect_equal(or3s(logi_anf, , ),
bor3(logi_anf, , ))
expect_equal(or3s(logi_ang, , ),
bor3(logi_ang, , ))
expect_equal(or3s(logi_anh, , !logi_s),
bor3(logi_anh, , !logi_s))
expect_equal(or3s(logi_ani, , !logi_w),
bor3(logi_ani, , !logi_w))
expect_equal(or3s(logi_anj, , !logi_y),
bor3(logi_anj, , !logi_y))
expect_equal(or3s(logi_ank, e == 0L, ),
bor3(logi_ank, e == 0L, ))
expect_equal(or3s(logi_anl, m == 1L, ),
bor3(logi_anl, m == 1L, ))
expect_equal(or3s(logi_anm, p == 9L, ),
bor3(logi_anm, p == 9L, ))
expect_equal(or3s(logi_ann, f == 0L, !logi_b),
bor3(logi_ann, f == 0L, !logi_b))
expect_equal(or3s(logi_ano, p == 1L, !logi_l),
bor3(logi_ano, p == 1L, !logi_l))
expect_equal(or3s(logi_anp, w == 9L, !logi_w),
bor3(logi_anp, w == 9L, !logi_w))
expect_equal(or3s(logi_anq, , ),
bor3(logi_anq, , ))
expect_equal(or3s(logi_anr, , ),
bor3(logi_anr, , ))
expect_equal(or3s(logi_ans, , ),
bor3(logi_ans, , ))
expect_equal(or3s(logi_ant, , f != 0L),
bor3(logi_ant, , f != 0L))
expect_equal(or3s(logi_anu, , h != 1L),
bor3(logi_anu, , h != 1L))
expect_equal(or3s(logi_anv, , r != 9L),
bor3(logi_anv, , r != 9L))
expect_equal(or3s(logi_anw, v == 0L, ),
bor3(logi_anw, v == 0L, ))
expect_equal(or3s(logi_anx, p == 1L, ),
bor3(logi_anx, p == 1L, ))
expect_equal(or3s(logi_any, k == 9L, ),
bor3(logi_any, k == 9L, ))
expect_equal(or3s(logi_anz, o == 0L, p != 0L),
bor3(logi_anz, o == 0L, p != 0L))
expect_equal(or3s(logi_aoa, y == 1L, i != 1L),
bor3(logi_aoa, y == 1L, i != 1L))
expect_equal(or3s(logi_aob, t == 9L, h != 9L),
bor3(logi_aob, t == 9L, h != 9L))
expect_equal(or3s(logi_aoc, , ),
bor3(logi_aoc, , ))
expect_equal(or3s(logi_aod, , ),
bor3(logi_aod, , ))
expect_equal(or3s(logi_aoe, , ),
bor3(logi_aoe, , ))
expect_equal(or3s(logi_aof, , x %between% c(-1L, 1L)),
bor3(logi_aof, , x %between% c(-1L, 1L)))
expect_equal(or3s(logi_aog, , t %between% c(-1L, 1L)),
bor3(logi_aog, , t %between% c(-1L, 1L)))
expect_equal(or3s(logi_aoh, , h %between% c(-1L, 1L)),
bor3(logi_aoh, , h %between% c(-1L, 1L)))
expect_equal(or3s(logi_aoi, j == 0L, ),
bor3(logi_aoi, j == 0L, ))
expect_equal(or3s(logi_aoj, h == 1L, ),
bor3(logi_aoj, h == 1L, ))
expect_equal(or3s(logi_aok, r == 9L, ),
bor3(logi_aok, r == 9L, ))
expect_equal(or3s(logi_aol, f == 0L, c %between% c(-1L, 1L)),
bor3(logi_aol, f == 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(logi_aom, f == 1L, c %between% c(-1L, 1L)),
bor3(logi_aom, f == 1L, c %between% c(-1L, 1L)))
expect_equal(or3s(logi_aon, q == 9L, k %between% c(-1L, 1L)),
bor3(logi_aon, q == 9L, k %between% c(-1L, 1L)))
expect_equal(or3s(logi_aoo, , ),
bor3(logi_aoo, , ))
expect_equal(or3s(logi_aop, , ),
bor3(logi_aop, , ))
expect_equal(or3s(logi_aoq, , ),
bor3(logi_aoq, , ))
expect_equal(or3s(logi_aor, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aor, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aos, , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aos, , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aot, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aot, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aou, o == 0L, ),
bor3(logi_aou, o == 0L, ))
expect_equal(or3s(logi_aov, p == 1L, ),
bor3(logi_aov, p == 1L, ))
expect_equal(or3s(logi_aow, k == 9L, ),
bor3(logi_aow, k == 9L, ))
expect_equal(or3s(logi_aox, z == 0L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aox, z == 0L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aoy, n == 1L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aoy, n == 1L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aoz, m == 9L, u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aoz, m == 9L, u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_apa, , ),
bor3(logi_apa, , ))
expect_equal(or3s(logi_apb, , ),
bor3(logi_apb, , ))
expect_equal(or3s(logi_apc, , ),
bor3(logi_apc, , ))
expect_equal(or3s(logi_apd, , d %in% 1:4),
bor3(logi_apd, , d %in% 1:4))
expect_equal(or3s(logi_ape, , w %in% 1:4),
bor3(logi_ape, , w %in% 1:4))
expect_equal(or3s(logi_apf, , t %in% 1:4),
bor3(logi_apf, , t %in% 1:4))
expect_equal(or3s(logi_apg, u == 0L, ),
bor3(logi_apg, u == 0L, ))
expect_equal(or3s(logi_aph, m == 1L, ),
bor3(logi_aph, m == 1L, ))
expect_equal(or3s(logi_api, o == 9L, ),
bor3(logi_api, o == 9L, ))
expect_equal(or3s(logi_apj, a == 0L, z %in% 1:4),
bor3(logi_apj, a == 0L, z %in% 1:4))
expect_equal(or3s(logi_apk, m == 1L, n %in% 1:4),
bor3(logi_apk, m == 1L, n %in% 1:4))
expect_equal(or3s(logi_apl, d == 9L, d %in% 1:4),
bor3(logi_apl, d == 9L, d %in% 1:4))
expect_equal(or3s(logi_apm, , ),
bor3(logi_apm, , ))
expect_equal(or3s(logi_apn, , ),
bor3(logi_apn, , ))
expect_equal(or3s(logi_apo, , ),
bor3(logi_apo, , ))
expect_equal(or3s(logi_app, , i < 0L),
bor3(logi_app, , i < 0L))
expect_equal(or3s(logi_apq, , k < 1L),
bor3(logi_apq, , k < 1L))
expect_equal(or3s(logi_apr, , t < 9L),
bor3(logi_apr, , t < 9L))
expect_equal(or3s(logi_aps, a == 0L, ),
bor3(logi_aps, a == 0L, ))
expect_equal(or3s(logi_apt, h == 1L, ),
bor3(logi_apt, h == 1L, ))
expect_equal(or3s(logi_apu, g == 9L, ),
bor3(logi_apu, g == 9L, ))
expect_equal(or3s(logi_apv, i == 0L, t < 0L),
bor3(logi_apv, i == 0L, t < 0L))
expect_equal(or3s(logi_apw, a == 1L, b < 1L),
bor3(logi_apw, a == 1L, b < 1L))
expect_equal(or3s(logi_apx, y == 9L, n < 9L),
bor3(logi_apx, y == 9L, n < 9L))
expect_equal(or3s(logi_apy, , ),
bor3(logi_apy, , ))
expect_equal(or3s(logi_apz, , ),
bor3(logi_apz, , ))
expect_equal(or3s(logi_aqa, , ),
bor3(logi_aqa, , ))
expect_equal(or3s(logi_aqb, , l <= 0L),
bor3(logi_aqb, , l <= 0L))
expect_equal(or3s(logi_aqc, , l <= 1L),
bor3(logi_aqc, , l <= 1L))
expect_equal(or3s(logi_aqd, , r <= 9L),
bor3(logi_aqd, , r <= 9L))
expect_equal(or3s(logi_aqe, r == 0L, ),
bor3(logi_aqe, r == 0L, ))
expect_equal(or3s(logi_aqf, k == 1L, ),
bor3(logi_aqf, k == 1L, ))
expect_equal(or3s(logi_aqg, s == 9L, ),
bor3(logi_aqg, s == 9L, ))
expect_equal(or3s(logi_aqh, u == 0L, i <= 0L),
bor3(logi_aqh, u == 0L, i <= 0L))
expect_equal(or3s(logi_aqi, c == 1L, j <= 1L),
bor3(logi_aqi, c == 1L, j <= 1L))
expect_equal(or3s(logi_aqj, n == 9L, n <= 9L),
bor3(logi_aqj, n == 9L, n <= 9L))
expect_equal(or3s(logi_aqk, , ),
bor3(logi_aqk, , ))
expect_equal(or3s(logi_aql, , ),
bor3(logi_aql, , ))
expect_equal(or3s(logi_aqm, , ),
bor3(logi_aqm, , ))
expect_equal(or3s(logi_aqn, , z == 0L),
bor3(logi_aqn, , z == 0L))
expect_equal(or3s(logi_aqo, , n == 1L),
bor3(logi_aqo, , n == 1L))
expect_equal(or3s(logi_aqp, , l == 9L),
bor3(logi_aqp, , l == 9L))
expect_equal(or3s(logi_aqq, p == 0L, ),
bor3(logi_aqq, p == 0L, ))
expect_equal(or3s(logi_aqr, s == 1L, ),
bor3(logi_aqr, s == 1L, ))
expect_equal(or3s(logi_aqs, b == 9L, ),
bor3(logi_aqs, b == 9L, ))
expect_equal(or3s(logi_aqt, u == 0L, x == 0L),
bor3(logi_aqt, u == 0L, x == 0L))
expect_equal(or3s(logi_aqu, n == 1L, j == 1L),
bor3(logi_aqu, n == 1L, j == 1L))
expect_equal(or3s(logi_aqv, v == 9L, h == 9L),
bor3(logi_aqv, v == 9L, h == 9L))
expect_equal(or3s(logi_aqw, , ),
bor3(logi_aqw, , ))
expect_equal(or3s(logi_aqx, , ),
bor3(logi_aqx, , ))
expect_equal(or3s(logi_aqy, , ),
bor3(logi_aqy, , ))
expect_equal(or3s(logi_aqz, , w > 0L),
bor3(logi_aqz, , w > 0L))
expect_equal(or3s(logi_ara, , p > 1L),
bor3(logi_ara, , p > 1L))
expect_equal(or3s(logi_arb, , l > 9L),
bor3(logi_arb, , l > 9L))
expect_equal(or3s(logi_arc, o == 0L, ),
bor3(logi_arc, o == 0L, ))
expect_equal(or3s(logi_ard, l == 1L, ),
bor3(logi_ard, l == 1L, ))
expect_equal(or3s(logi_are, h == 9L, ),
bor3(logi_are, h == 9L, ))
expect_equal(or3s(logi_arf, h == 0L, r > 0L),
bor3(logi_arf, h == 0L, r > 0L))
expect_equal(or3s(logi_arg, h == 1L, y > 1L),
bor3(logi_arg, h == 1L, y > 1L))
expect_equal(or3s(logi_arh, g == 9L, q > 9L),
bor3(logi_arh, g == 9L, q > 9L))
expect_equal(or3s(logi_ari, , ),
bor3(logi_ari, , ))
expect_equal(or3s(logi_arj, , ),
bor3(logi_arj, , ))
expect_equal(or3s(logi_ark, , ),
bor3(logi_ark, , ))
expect_equal(or3s(logi_arl, , h >= 0L),
bor3(logi_arl, , h >= 0L))
expect_equal(or3s(logi_arm, , a >= 1L),
bor3(logi_arm, , a >= 1L))
expect_equal(or3s(logi_arn, , g >= 9L),
bor3(logi_arn, , g >= 9L))
expect_equal(or3s(logi_aro, b == 0L, ),
bor3(logi_aro, b == 0L, ))
expect_equal(or3s(logi_arp, a == 1L, ),
bor3(logi_arp, a == 1L, ))
expect_equal(or3s(logi_arq, r == 9L, ),
bor3(logi_arq, r == 9L, ))
expect_equal(or3s(logi_arr, s == 0L, k >= 0L),
bor3(logi_arr, s == 0L, k >= 0L))
expect_equal(or3s(logi_ars, h == 1L, q >= 1L),
bor3(logi_ars, h == 1L, q >= 1L))
expect_equal(or3s(logi_art, h == 9L, c >= 9L),
bor3(logi_art, h == 9L, c >= 9L))
expect_equal(or3s(logi_aru, , ),
bor3(logi_aru, , ))
expect_equal(or3s(logi_arv, , ),
bor3(logi_arv, , ))
expect_equal(or3s(logi_arw, , ),
bor3(logi_arw, , ))
expect_equal(or3s(logi_arx, , logi_x),
bor3(logi_arx, , logi_x))
expect_equal(or3s(logi_ary, , logi_b),
bor3(logi_ary, , logi_b))
expect_equal(or3s(logi_arz, , logi_q),
bor3(logi_arz, , logi_q))
expect_equal(or3s(logi_asa, b > 0L, ),
bor3(logi_asa, b > 0L, ))
expect_equal(or3s(logi_asb, i > 1L, ),
bor3(logi_asb, i > 1L, ))
expect_equal(or3s(logi_asc, f > 9L, ),
bor3(logi_asc, f > 9L, ))
expect_equal(or3s(logi_asd, s > 0L, logi_k),
bor3(logi_asd, s > 0L, logi_k))
expect_equal(or3s(logi_ase, d > 1L, logi_u),
bor3(logi_ase, d > 1L, logi_u))
expect_equal(or3s(logi_asf, v > 9L, logi_g),
bor3(logi_asf, v > 9L, logi_g))
expect_equal(or3s(logi_asg, , ),
bor3(logi_asg, , ))
expect_equal(or3s(logi_ash, , ),
bor3(logi_ash, , ))
expect_equal(or3s(logi_asi, , ),
bor3(logi_asi, , ))
expect_equal(or3s(logi_asj, , !logi_l),
bor3(logi_asj, , !logi_l))
expect_equal(or3s(logi_ask, , !logi_z),
bor3(logi_ask, , !logi_z))
expect_equal(or3s(logi_asl, , !logi_t),
bor3(logi_asl, , !logi_t))
expect_equal(or3s(logi_asm, c > 0L, ),
bor3(logi_asm, c > 0L, ))
expect_equal(or3s(logi_asn, m > 1L, ),
bor3(logi_asn, m > 1L, ))
expect_equal(or3s(logi_aso, t > 9L, ),
bor3(logi_aso, t > 9L, ))
expect_equal(or3s(logi_asp, f > 0L, !logi_n),
bor3(logi_asp, f > 0L, !logi_n))
expect_equal(or3s(logi_asq, i > 1L, !logi_p),
bor3(logi_asq, i > 1L, !logi_p))
expect_equal(or3s(logi_asr, i > 9L, !logi_s),
bor3(logi_asr, i > 9L, !logi_s))
expect_equal(or3s(logi_ass, , ),
bor3(logi_ass, , ))
expect_equal(or3s(logi_ast, , ),
bor3(logi_ast, , ))
expect_equal(or3s(logi_asu, , ),
bor3(logi_asu, , ))
expect_equal(or3s(logi_asv, , o != 0L),
bor3(logi_asv, , o != 0L))
expect_equal(or3s(logi_asw, , k != 1L),
bor3(logi_asw, , k != 1L))
expect_equal(or3s(logi_asx, , b != 9L),
bor3(logi_asx, , b != 9L))
expect_equal(or3s(logi_asy, w > 0L, ),
bor3(logi_asy, w > 0L, ))
expect_equal(or3s(logi_asz, r > 1L, ),
bor3(logi_asz, r > 1L, ))
expect_equal(or3s(logi_ata, v > 9L, ),
bor3(logi_ata, v > 9L, ))
expect_equal(or3s(logi_atb, b > 0L, i != 0L),
bor3(logi_atb, b > 0L, i != 0L))
expect_equal(or3s(logi_atc, u > 1L, b != 1L),
bor3(logi_atc, u > 1L, b != 1L))
expect_equal(or3s(logi_atd, k > 9L, m != 9L),
bor3(logi_atd, k > 9L, m != 9L))
expect_equal(or3s(logi_ate, , ),
bor3(logi_ate, , ))
expect_equal(or3s(logi_atf, , ),
bor3(logi_atf, , ))
expect_equal(or3s(logi_atg, , ),
bor3(logi_atg, , ))
expect_equal(or3s(logi_ath, , d %between% c(-1L, 1L)),
bor3(logi_ath, , d %between% c(-1L, 1L)))
expect_equal(or3s(logi_ati, , y %between% c(-1L, 1L)),
bor3(logi_ati, , y %between% c(-1L, 1L)))
expect_equal(or3s(logi_atj, , s %between% c(-1L, 1L)),
bor3(logi_atj, , s %between% c(-1L, 1L)))
expect_equal(or3s(logi_atk, m > 0L, ),
bor3(logi_atk, m > 0L, ))
expect_equal(or3s(logi_atl, d > 1L, ),
bor3(logi_atl, d > 1L, ))
expect_equal(or3s(logi_atm, u > 9L, ),
bor3(logi_atm, u > 9L, ))
expect_equal(or3s(logi_atn, n > 0L, g %between% c(-1L, 1L)),
bor3(logi_atn, n > 0L, g %between% c(-1L, 1L)))
expect_equal(or3s(logi_ato, w > 1L, z %between% c(-1L, 1L)),
bor3(logi_ato, w > 1L, z %between% c(-1L, 1L)))
expect_equal(or3s(logi_atp, n > 9L, x %between% c(-1L, 1L)),
bor3(logi_atp, n > 9L, x %between% c(-1L, 1L)))
expect_equal(or3s(logi_atq, , ),
bor3(logi_atq, , ))
expect_equal(or3s(logi_atr, , ),
bor3(logi_atr, , ))
expect_equal(or3s(logi_ats, , ),
bor3(logi_ats, , ))
expect_equal(or3s(logi_att, , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_att, , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_atu, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_atu, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_atv, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_atv, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_atw, r > 0L, ),
bor3(logi_atw, r > 0L, ))
expect_equal(or3s(logi_atx, c > 1L, ),
bor3(logi_atx, c > 1L, ))
expect_equal(or3s(logi_aty, i > 9L, ),
bor3(logi_aty, i > 9L, ))
expect_equal(or3s(logi_atz, l > 0L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_atz, l > 0L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aua, p > 1L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aua, p > 1L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_aub, n > 9L, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_aub, n > 9L, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_auc, , ),
bor3(logi_auc, , ))
expect_equal(or3s(logi_aud, , ),
bor3(logi_aud, , ))
expect_equal(or3s(logi_aue, , ),
bor3(logi_aue, , ))
expect_equal(or3s(logi_auf, , e %in% 1:4),
bor3(logi_auf, , e %in% 1:4))
expect_equal(or3s(logi_aug, , f %in% 1:4),
bor3(logi_aug, , f %in% 1:4))
expect_equal(or3s(logi_auh, , t %in% 1:4),
bor3(logi_auh, , t %in% 1:4))
expect_equal(or3s(logi_aui, o > 0L, ),
bor3(logi_aui, o > 0L, ))
expect_equal(or3s(logi_auj, x > 1L, ),
bor3(logi_auj, x > 1L, ))
expect_equal(or3s(logi_auk, c > 9L, ),
bor3(logi_auk, c > 9L, ))
expect_equal(or3s(logi_aul, x > 0L, c %in% 1:4),
bor3(logi_aul, x > 0L, c %in% 1:4))
expect_equal(or3s(logi_aum, o > 1L, e %in% 1:4),
bor3(logi_aum, o > 1L, e %in% 1:4))
expect_equal(or3s(logi_aun, w > 9L, b %in% 1:4),
bor3(logi_aun, w > 9L, b %in% 1:4))
expect_equal(or3s(logi_auo, , ),
bor3(logi_auo, , ))
expect_equal(or3s(logi_aup, , ),
bor3(logi_aup, , ))
expect_equal(or3s(logi_auq, , ),
bor3(logi_auq, , ))
expect_equal(or3s(logi_aur, , t < 0L),
bor3(logi_aur, , t < 0L))
expect_equal(or3s(logi_aus, , s < 1L),
bor3(logi_aus, , s < 1L))
expect_equal(or3s(logi_aut, , h < 9L),
bor3(logi_aut, , h < 9L))
expect_equal(or3s(logi_auu, d > 0L, ),
bor3(logi_auu, d > 0L, ))
expect_equal(or3s(logi_auv, q > 1L, ),
bor3(logi_auv, q > 1L, ))
expect_equal(or3s(logi_auw, y > 9L, ),
bor3(logi_auw, y > 9L, ))
expect_equal(or3s(logi_aux, i > 0L, s < 0L),
bor3(logi_aux, i > 0L, s < 0L))
expect_equal(or3s(logi_auy, f > 1L, t < 1L),
bor3(logi_auy, f > 1L, t < 1L))
expect_equal(or3s(logi_auz, n > 9L, m < 9L),
bor3(logi_auz, n > 9L, m < 9L))
expect_equal(or3s(logi_ava, , ),
bor3(logi_ava, , ))
expect_equal(or3s(logi_avb, , ),
bor3(logi_avb, , ))
expect_equal(or3s(logi_avc, , ),
bor3(logi_avc, , ))
expect_equal(or3s(logi_avd, , m <= 0L),
bor3(logi_avd, , m <= 0L))
expect_equal(or3s(logi_ave, , m <= 1L),
bor3(logi_ave, , m <= 1L))
expect_equal(or3s(logi_avf, , v <= 9L),
bor3(logi_avf, , v <= 9L))
expect_equal(or3s(logi_avg, h > 0L, ),
bor3(logi_avg, h > 0L, ))
expect_equal(or3s(logi_avh, b > 1L, ),
bor3(logi_avh, b > 1L, ))
expect_equal(or3s(logi_avi, x > 9L, ),
bor3(logi_avi, x > 9L, ))
expect_equal(or3s(logi_avj, z > 0L, m <= 0L),
bor3(logi_avj, z > 0L, m <= 0L))
expect_equal(or3s(logi_avk, m > 1L, b <= 1L),
bor3(logi_avk, m > 1L, b <= 1L))
expect_equal(or3s(logi_avl, v > 9L, d <= 9L),
bor3(logi_avl, v > 9L, d <= 9L))
expect_equal(or3s(logi_avm, , ),
bor3(logi_avm, , ))
expect_equal(or3s(logi_avn, , ),
bor3(logi_avn, , ))
expect_equal(or3s(logi_avo, , ),
bor3(logi_avo, , ))
expect_equal(or3s(logi_avp, , e == 0L),
bor3(logi_avp, , e == 0L))
expect_equal(or3s(logi_avq, , g == 1L),
bor3(logi_avq, , g == 1L))
expect_equal(or3s(logi_avr, , n == 9L),
bor3(logi_avr, , n == 9L))
expect_equal(or3s(logi_avs, r > 0L, ),
bor3(logi_avs, r > 0L, ))
expect_equal(or3s(logi_avt, x > 1L, ),
bor3(logi_avt, x > 1L, ))
expect_equal(or3s(logi_avu, k > 9L, ),
bor3(logi_avu, k > 9L, ))
expect_equal(or3s(logi_avv, e > 0L, p == 0L),
bor3(logi_avv, e > 0L, p == 0L))
expect_equal(or3s(logi_avw, g > 1L, p == 1L),
bor3(logi_avw, g > 1L, p == 1L))
expect_equal(or3s(logi_avx, p > 9L, m == 9L),
bor3(logi_avx, p > 9L, m == 9L))
expect_equal(or3s(logi_avy, , ),
bor3(logi_avy, , ))
expect_equal(or3s(logi_avz, , ),
bor3(logi_avz, , ))
expect_equal(or3s(logi_awa, , ),
bor3(logi_awa, , ))
expect_equal(or3s(logi_awb, , l > 0L),
bor3(logi_awb, , l > 0L))
expect_equal(or3s(logi_awc, , z > 1L),
bor3(logi_awc, , z > 1L))
expect_equal(or3s(logi_awd, , g > 9L),
bor3(logi_awd, , g > 9L))
expect_equal(or3s(logi_awe, g > 0L, ),
bor3(logi_awe, g > 0L, ))
expect_equal(or3s(logi_awf, v > 1L, ),
bor3(logi_awf, v > 1L, ))
expect_equal(or3s(logi_awg, v > 9L, ),
bor3(logi_awg, v > 9L, ))
expect_equal(or3s(logi_awh, p > 0L, q > 0L),
bor3(logi_awh, p > 0L, q > 0L))
expect_equal(or3s(logi_awi, v > 1L, t > 1L),
bor3(logi_awi, v > 1L, t > 1L))
expect_equal(or3s(logi_awj, y > 9L, y > 9L),
bor3(logi_awj, y > 9L, y > 9L))
expect_equal(or3s(logi_awk, , ),
bor3(logi_awk, , ))
expect_equal(or3s(logi_awl, , ),
bor3(logi_awl, , ))
expect_equal(or3s(logi_awm, , ),
bor3(logi_awm, , ))
expect_equal(or3s(logi_awn, , k >= 0L),
bor3(logi_awn, , k >= 0L))
expect_equal(or3s(logi_awo, , r >= 1L),
bor3(logi_awo, , r >= 1L))
expect_equal(or3s(logi_awp, , t >= 9L),
bor3(logi_awp, , t >= 9L))
expect_equal(or3s(logi_awq, f > 0L, ),
bor3(logi_awq, f > 0L, ))
expect_equal(or3s(logi_awr, o > 1L, ),
bor3(logi_awr, o > 1L, ))
expect_equal(or3s(logi_aws, w > 9L, ),
bor3(logi_aws, w > 9L, ))
expect_equal(or3s(logi_awt, i > 0L, a >= 0L),
bor3(logi_awt, i > 0L, a >= 0L))
expect_equal(or3s(logi_awu, b > 1L, t >= 1L),
bor3(logi_awu, b > 1L, t >= 1L))
expect_equal(or3s(logi_awv, z > 9L, s >= 9L),
bor3(logi_awv, z > 9L, s >= 9L))
expect_equal(or3s(logi_aww, , ),
bor3(logi_aww, , ))
expect_equal(or3s(logi_awx, , ),
bor3(logi_awx, , ))
expect_equal(or3s(logi_awy, , ),
bor3(logi_awy, , ))
expect_equal(or3s(logi_awz, , logi_h),
bor3(logi_awz, , logi_h))
expect_equal(or3s(logi_axa, , logi_s),
bor3(logi_axa, , logi_s))
expect_equal(or3s(logi_axb, , logi_j),
bor3(logi_axb, , logi_j))
expect_equal(or3s(logi_axc, b >= 0L, ),
bor3(logi_axc, b >= 0L, ))
expect_equal(or3s(logi_axd, p >= 1L, ),
bor3(logi_axd, p >= 1L, ))
expect_equal(or3s(logi_axe, u >= 9L, ),
bor3(logi_axe, u >= 9L, ))
expect_equal(or3s(logi_axf, c >= 0L, logi_l),
bor3(logi_axf, c >= 0L, logi_l))
expect_equal(or3s(logi_axg, i >= 1L, logi_r),
bor3(logi_axg, i >= 1L, logi_r))
expect_equal(or3s(logi_axh, p >= 9L, logi_k),
bor3(logi_axh, p >= 9L, logi_k))
expect_equal(or3s(logi_axi, , ),
bor3(logi_axi, , ))
expect_equal(or3s(logi_axj, , ),
bor3(logi_axj, , ))
expect_equal(or3s(logi_axk, , ),
bor3(logi_axk, , ))
expect_equal(or3s(logi_axl, , !logi_p),
bor3(logi_axl, , !logi_p))
expect_equal(or3s(logi_axm, , !logi_i),
bor3(logi_axm, , !logi_i))
expect_equal(or3s(logi_axn, , !logi_b),
bor3(logi_axn, , !logi_b))
expect_equal(or3s(logi_axo, e >= 0L, ),
bor3(logi_axo, e >= 0L, ))
expect_equal(or3s(logi_axp, d >= 1L, ),
bor3(logi_axp, d >= 1L, ))
expect_equal(or3s(logi_axq, y >= 9L, ),
bor3(logi_axq, y >= 9L, ))
expect_equal(or3s(logi_axr, b >= 0L, !logi_o),
bor3(logi_axr, b >= 0L, !logi_o))
expect_equal(or3s(logi_axs, i >= 1L, !logi_z),
bor3(logi_axs, i >= 1L, !logi_z))
expect_equal(or3s(logi_axt, x >= 9L, !logi_f),
bor3(logi_axt, x >= 9L, !logi_f))
expect_equal(or3s(logi_axu, , ),
bor3(logi_axu, , ))
expect_equal(or3s(logi_axv, , ),
bor3(logi_axv, , ))
expect_equal(or3s(logi_axw, , ),
bor3(logi_axw, , ))
expect_equal(or3s(logi_axx, , u != 0L),
bor3(logi_axx, , u != 0L))
expect_equal(or3s(logi_axy, , u != 1L),
bor3(logi_axy, , u != 1L))
expect_equal(or3s(logi_axz, , r != 9L),
bor3(logi_axz, , r != 9L))
expect_equal(or3s(logi_aya, g >= 0L, ),
bor3(logi_aya, g >= 0L, ))
expect_equal(or3s(logi_ayb, x >= 1L, ),
bor3(logi_ayb, x >= 1L, ))
expect_equal(or3s(logi_ayc, b >= 9L, ),
bor3(logi_ayc, b >= 9L, ))
expect_equal(or3s(logi_ayd, i >= 0L, x != 0L),
bor3(logi_ayd, i >= 0L, x != 0L))
expect_equal(or3s(logi_aye, e >= 1L, v != 1L),
bor3(logi_aye, e >= 1L, v != 1L))
expect_equal(or3s(logi_ayf, x >= 9L, r != 9L),
bor3(logi_ayf, x >= 9L, r != 9L))
expect_equal(or3s(logi_ayg, , ),
bor3(logi_ayg, , ))
expect_equal(or3s(logi_ayh, , ),
bor3(logi_ayh, , ))
expect_equal(or3s(logi_ayi, , ),
bor3(logi_ayi, , ))
expect_equal(or3s(logi_ayj, , e %between% c(-1L, 1L)),
bor3(logi_ayj, , e %between% c(-1L, 1L)))
expect_equal(or3s(logi_ayk, , l %between% c(-1L, 1L)),
bor3(logi_ayk, , l %between% c(-1L, 1L)))
expect_equal(or3s(logi_ayl, , b %between% c(-1L, 1L)),
bor3(logi_ayl, , b %between% c(-1L, 1L)))
expect_equal(or3s(logi_aym, l >= 0L, ),
bor3(logi_aym, l >= 0L, ))
expect_equal(or3s(logi_ayn, t >= 1L, ),
bor3(logi_ayn, t >= 1L, ))
expect_equal(or3s(logi_ayo, n >= 9L, ),
bor3(logi_ayo, n >= 9L, ))
expect_equal(or3s(logi_ayp, l >= 0L, r %between% c(-1L, 1L)),
bor3(logi_ayp, l >= 0L, r %between% c(-1L, 1L)))
expect_equal(or3s(logi_ayq, m >= 1L, j %between% c(-1L, 1L)),
bor3(logi_ayq, m >= 1L, j %between% c(-1L, 1L)))
expect_equal(or3s(logi_ayr, q >= 9L, q %between% c(-1L, 1L)),
bor3(logi_ayr, q >= 9L, q %between% c(-1L, 1L)))
expect_equal(or3s(logi_ays, , ),
bor3(logi_ays, , ))
expect_equal(or3s(logi_ayt, , ),
bor3(logi_ayt, , ))
expect_equal(or3s(logi_ayu, , ),
bor3(logi_ayu, , ))
expect_equal(or3s(logi_ayv, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ayv, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ayw, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ayw, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ayx, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_ayx, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_ayy, s >= 0L, ),
bor3(logi_ayy, s >= 0L, ))
expect_equal(or3s(logi_ayz, e >= 1L, ),
bor3(logi_ayz, e >= 1L, ))
expect_equal(or3s(logi_ba, r >= 9L, ),
bor3(logi_ba, r >= 9L, ))
expect_equal(or3s(logi_bb, n >= 0L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bb, n >= 0L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bc, g >= 1L, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bc, g >= 1L, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_bd, h >= 9L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(logi_bd, h >= 9L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(logi_be, , ),
bor3(logi_be, , ))
expect_equal(or3s(logi_bf, , ),
bor3(logi_bf, , ))
expect_equal(or3s(logi_bg, , ),
bor3(logi_bg, , ))
expect_equal(or3s(logi_bh, , z %in% 1:4),
bor3(logi_bh, , z %in% 1:4))
expect_equal(or3s(logi_bi, , z %in% 1:4),
bor3(logi_bi, , z %in% 1:4))
expect_equal(or3s(logi_bj, , w %in% 1:4),
bor3(logi_bj, , w %in% 1:4))
expect_equal(or3s(logi_bk, k >= 0L, ),
bor3(logi_bk, k >= 0L, ))
expect_equal(or3s(logi_bl, i >= 1L, ),
bor3(logi_bl, i >= 1L, ))
expect_equal(or3s(logi_bm, b >= 9L, ),
bor3(logi_bm, b >= 9L, ))
expect_equal(or3s(logi_bn, d >= 0L, n %in% 1:4),
bor3(logi_bn, d >= 0L, n %in% 1:4))
expect_equal(or3s(logi_bo, k >= 1L, c %in% 1:4),
bor3(logi_bo, k >= 1L, c %in% 1:4))
expect_equal(or3s(logi_bp, o >= 9L, h %in% 1:4),
bor3(logi_bp, o >= 9L, h %in% 1:4))
expect_equal(or3s(logi_bq, , ),
bor3(logi_bq, , ))
expect_equal(or3s(logi_br, , ),
bor3(logi_br, , ))
expect_equal(or3s(logi_bs, , ),
bor3(logi_bs, , ))
expect_equal(or3s(logi_bt, , q < 0L),
bor3(logi_bt, , q < 0L))
expect_equal(or3s(logi_bu, , e < 1L),
bor3(logi_bu, , e < 1L))
expect_equal(or3s(logi_bv, , i < 9L),
bor3(logi_bv, , i < 9L))
expect_equal(or3s(logi_bw, u >= 0L, ),
bor3(logi_bw, u >= 0L, ))
expect_equal(or3s(logi_bx, d >= 1L, ),
bor3(logi_bx, d >= 1L, ))
expect_equal(or3s(logi_by, n >= 9L, ),
bor3(logi_by, n >= 9L, ))
expect_equal(or3s(logi_bz, k >= 0L, j < 0L),
bor3(logi_bz, k >= 0L, j < 0L))
expect_equal(or3s(logi_baa, e >= 1L, r < 1L),
bor3(logi_baa, e >= 1L, r < 1L))
expect_equal(or3s(logi_bab, x >= 9L, r < 9L),
bor3(logi_bab, x >= 9L, r < 9L))
expect_equal(or3s(logi_bac, , ),
bor3(logi_bac, , ))
expect_equal(or3s(logi_bad, , ),
bor3(logi_bad, , ))
expect_equal(or3s(logi_bae, , ),
bor3(logi_bae, , ))
expect_equal(or3s(logi_baf, , o <= 0L),
bor3(logi_baf, , o <= 0L))
expect_equal(or3s(logi_bag, , g <= 1L),
bor3(logi_bag, , g <= 1L))
expect_equal(or3s(logi_bah, , e <= 9L),
bor3(logi_bah, , e <= 9L))
expect_equal(or3s(logi_bai, a >= 0L, ),
bor3(logi_bai, a >= 0L, ))
expect_equal(or3s(logi_baj, m >= 1L, ),
bor3(logi_baj, m >= 1L, ))
expect_equal(or3s(logi_bak, q >= 9L, ),
bor3(logi_bak, q >= 9L, ))
expect_equal(or3s(logi_bal, q >= 0L, l <= 0L),
bor3(logi_bal, q >= 0L, l <= 0L))
expect_equal(or3s(logi_bam, o >= 1L, c <= 1L),
bor3(logi_bam, o >= 1L, c <= 1L))
expect_equal(or3s(logi_ban, a >= 9L, k <= 9L),
bor3(logi_ban, a >= 9L, k <= 9L))
expect_equal(or3s(logi_bao, , ),
bor3(logi_bao, , ))
expect_equal(or3s(logi_bap, , ),
bor3(logi_bap, , ))
expect_equal(or3s(logi_baq, , ),
bor3(logi_baq, , ))
expect_equal(or3s(logi_bar, , n == 0L),
bor3(logi_bar, , n == 0L))
expect_equal(or3s(logi_bas, , i == 1L),
bor3(logi_bas, , i == 1L))
expect_equal(or3s(logi_bat, , n == 9L),
bor3(logi_bat, , n == 9L))
expect_equal(or3s(logi_bau, q >= 0L, ),
bor3(logi_bau, q >= 0L, ))
expect_equal(or3s(logi_bav, r >= 1L, ),
bor3(logi_bav, r >= 1L, ))
expect_equal(or3s(logi_baw, p >= 9L, ),
bor3(logi_baw, p >= 9L, ))
expect_equal(or3s(logi_bax, r >= 0L, x == 0L),
bor3(logi_bax, r >= 0L, x == 0L))
expect_equal(or3s(logi_bay, n >= 1L, u == 1L),
bor3(logi_bay, n >= 1L, u == 1L))
expect_equal(or3s(logi_baz, z >= 9L, h == 9L),
bor3(logi_baz, z >= 9L, h == 9L))
expect_equal(or3s(logi_bba, , ),
bor3(logi_bba, , ))
expect_equal(or3s(logi_bbb, , ),
bor3(logi_bbb, , ))
expect_equal(or3s(logi_bbc, , ),
bor3(logi_bbc, , ))
expect_equal(or3s(logi_bbd, , i > 0L),
bor3(logi_bbd, , i > 0L))
expect_equal(or3s(logi_bbe, , y > 1L),
bor3(logi_bbe, , y > 1L))
expect_equal(or3s(logi_bbf, , t > 9L),
bor3(logi_bbf, , t > 9L))
expect_equal(or3s(logi_bbg, t >= 0L, ),
bor3(logi_bbg, t >= 0L, ))
expect_equal(or3s(logi_bbh, f >= 1L, ),
bor3(logi_bbh, f >= 1L, ))
expect_equal(or3s(logi_bbi, k >= 9L, ),
bor3(logi_bbi, k >= 9L, ))
expect_equal(or3s(logi_bbj, r >= 0L, m > 0L),
bor3(logi_bbj, r >= 0L, m > 0L))
expect_equal(or3s(logi_bbk, i >= 1L, d > 1L),
bor3(logi_bbk, i >= 1L, d > 1L))
expect_equal(or3s(logi_bbl, t >= 9L, k > 9L),
bor3(logi_bbl, t >= 9L, k > 9L))
expect_equal(or3s(logi_bbm, , ),
bor3(logi_bbm, , ))
expect_equal(or3s(logi_bbn, , ),
bor3(logi_bbn, , ))
expect_equal(or3s(logi_bbo, , ),
bor3(logi_bbo, , ))
expect_equal(or3s(logi_bbp, , l >= 0L),
bor3(logi_bbp, , l >= 0L))
expect_equal(or3s(logi_bbq, , m >= 1L),
bor3(logi_bbq, , m >= 1L))
expect_equal(or3s(logi_bbr, , x >= 9L),
bor3(logi_bbr, , x >= 9L))
expect_equal(or3s(logi_bbs, v >= 0L, ),
bor3(logi_bbs, v >= 0L, ))
expect_equal(or3s(logi_bbt, j >= 1L, ),
bor3(logi_bbt, j >= 1L, ))
expect_equal(or3s(logi_bbu, s >= 9L, ),
bor3(logi_bbu, s >= 9L, ))
expect_equal(or3s(logi_bbv, p >= 0L, u >= 0L),
bor3(logi_bbv, p >= 0L, u >= 0L))
expect_equal(or3s(logi_bbw, w >= 1L, a >= 1L),
bor3(logi_bbw, w >= 1L, a >= 1L))
expect_equal(or3s(logi_bbx, f >= 9L, o >= 9L),
bor3(logi_bbx, f >= 9L, o >= 9L))
expect_equal(or3s(!logi_bby, , ),
bor3(!logi_bby, , ))
expect_equal(or3s(!logi_bbz, , ),
bor3(!logi_bbz, , ))
expect_equal(or3s(!logi_bca, , ),
bor3(!logi_bca, , ))
expect_equal(or3s(!logi_bcb, , logi_l),
bor3(!logi_bcb, , logi_l))
expect_equal(or3s(!logi_bcc, , logi_n),
bor3(!logi_bcc, , logi_n))
expect_equal(or3s(!logi_bcd, , logi_b),
bor3(!logi_bcd, , logi_b))
expect_equal(or3s(!logi_bce, logi_t, ),
bor3(!logi_bce, logi_t, ))
expect_equal(or3s(!logi_bcf, logi_x, ),
bor3(!logi_bcf, logi_x, ))
expect_equal(or3s(!logi_bcg, logi_h, ),
bor3(!logi_bcg, logi_h, ))
expect_equal(or3s(!logi_bch, logi_h, logi_i),
bor3(!logi_bch, logi_h, logi_i))
expect_equal(or3s(!logi_bci, logi_f, logi_v),
bor3(!logi_bci, logi_f, logi_v))
expect_equal(or3s(!logi_bcj, logi_f, logi_i),
bor3(!logi_bcj, logi_f, logi_i))
expect_equal(or3s(!logi_bck, , ),
bor3(!logi_bck, , ))
expect_equal(or3s(!logi_bcl, , ),
bor3(!logi_bcl, , ))
expect_equal(or3s(!logi_bcm, , ),
bor3(!logi_bcm, , ))
expect_equal(or3s(!logi_bcn, , !logi_w),
bor3(!logi_bcn, , !logi_w))
expect_equal(or3s(!logi_bco, , !logi_v),
bor3(!logi_bco, , !logi_v))
expect_equal(or3s(!logi_bcp, , !logi_i),
bor3(!logi_bcp, , !logi_i))
expect_equal(or3s(!logi_bcq, logi_b, ),
bor3(!logi_bcq, logi_b, ))
expect_equal(or3s(!logi_bcr, logi_l, ),
bor3(!logi_bcr, logi_l, ))
expect_equal(or3s(!logi_bcs, logi_l, ),
bor3(!logi_bcs, logi_l, ))
expect_equal(or3s(!logi_bct, logi_i, !logi_b),
bor3(!logi_bct, logi_i, !logi_b))
expect_equal(or3s(!logi_bcu, logi_h, !logi_f),
bor3(!logi_bcu, logi_h, !logi_f))
expect_equal(or3s(!logi_bcv, logi_f, !logi_n),
bor3(!logi_bcv, logi_f, !logi_n))
expect_equal(or3s(!logi_bcw, , ),
bor3(!logi_bcw, , ))
expect_equal(or3s(!logi_bcx, , ),
bor3(!logi_bcx, , ))
expect_equal(or3s(!logi_bcy, , ),
bor3(!logi_bcy, , ))
expect_equal(or3s(!logi_bcz, , f != 0L),
bor3(!logi_bcz, , f != 0L))
expect_equal(or3s(!logi_bda, , e != 1L),
bor3(!logi_bda, , e != 1L))
expect_equal(or3s(!logi_bdb, , r != 9L),
bor3(!logi_bdb, , r != 9L))
expect_equal(or3s(!logi_bdc, logi_s, ),
bor3(!logi_bdc, logi_s, ))
expect_equal(or3s(!logi_bdd, logi_s, ),
bor3(!logi_bdd, logi_s, ))
expect_equal(or3s(!logi_bde, logi_b, ),
bor3(!logi_bde, logi_b, ))
expect_equal(or3s(!logi_bdf, logi_c, p != 0L),
bor3(!logi_bdf, logi_c, p != 0L))
expect_equal(or3s(!logi_bdg, logi_n, b != 1L),
bor3(!logi_bdg, logi_n, b != 1L))
expect_equal(or3s(!logi_bdh, logi_g, c != 9L),
bor3(!logi_bdh, logi_g, c != 9L))
expect_equal(or3s(!logi_bdi, , ),
bor3(!logi_bdi, , ))
expect_equal(or3s(!logi_bdj, , ),
bor3(!logi_bdj, , ))
expect_equal(or3s(!logi_bdk, , ),
bor3(!logi_bdk, , ))
expect_equal(or3s(!logi_bdl, , t %between% c(-1L, 1L)),
bor3(!logi_bdl, , t %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bdm, , p %between% c(-1L, 1L)),
bor3(!logi_bdm, , p %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bdn, , m %between% c(-1L, 1L)),
bor3(!logi_bdn, , m %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bdo, logi_i, ),
bor3(!logi_bdo, logi_i, ))
expect_equal(or3s(!logi_bdp, logi_w, ),
bor3(!logi_bdp, logi_w, ))
expect_equal(or3s(!logi_bdq, logi_t, ),
bor3(!logi_bdq, logi_t, ))
expect_equal(or3s(!logi_bdr, logi_e, t %between% c(-1L, 1L)),
bor3(!logi_bdr, logi_e, t %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bds, logi_t, r %between% c(-1L, 1L)),
bor3(!logi_bds, logi_t, r %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bdt, logi_j, c %between% c(-1L, 1L)),
bor3(!logi_bdt, logi_j, c %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bdu, , ),
bor3(!logi_bdu, , ))
expect_equal(or3s(!logi_bdv, , ),
bor3(!logi_bdv, , ))
expect_equal(or3s(!logi_bdw, , ),
bor3(!logi_bdw, , ))
expect_equal(or3s(!logi_bdx, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bdx, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bdy, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bdy, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bdz, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bdz, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bea, logi_b, ),
bor3(!logi_bea, logi_b, ))
expect_equal(or3s(!logi_beb, logi_o, ),
bor3(!logi_beb, logi_o, ))
expect_equal(or3s(!logi_bec, logi_d, ),
bor3(!logi_bec, logi_d, ))
expect_equal(or3s(!logi_bed, logi_v, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bed, logi_v, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bee, logi_m, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bee, logi_m, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bef, logi_e, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bef, logi_e, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_beg, , ),
bor3(!logi_beg, , ))
expect_equal(or3s(!logi_beh, , ),
bor3(!logi_beh, , ))
expect_equal(or3s(!logi_bei, , ),
bor3(!logi_bei, , ))
expect_equal(or3s(!logi_bej, , t %in% 1:4),
bor3(!logi_bej, , t %in% 1:4))
expect_equal(or3s(!logi_bek, , v %in% 1:4),
bor3(!logi_bek, , v %in% 1:4))
expect_equal(or3s(!logi_bel, , e %in% 1:4),
bor3(!logi_bel, , e %in% 1:4))
expect_equal(or3s(!logi_bem, logi_l, ),
bor3(!logi_bem, logi_l, ))
expect_equal(or3s(!logi_ben, logi_s, ),
bor3(!logi_ben, logi_s, ))
expect_equal(or3s(!logi_beo, logi_b, ),
bor3(!logi_beo, logi_b, ))
expect_equal(or3s(!logi_bep, logi_c, r %in% 1:4),
bor3(!logi_bep, logi_c, r %in% 1:4))
expect_equal(or3s(!logi_beq, logi_j, u %in% 1:4),
bor3(!logi_beq, logi_j, u %in% 1:4))
expect_equal(or3s(!logi_ber, logi_l, e %in% 1:4),
bor3(!logi_ber, logi_l, e %in% 1:4))
expect_equal(or3s(!logi_bes, , ),
bor3(!logi_bes, , ))
expect_equal(or3s(!logi_bet, , ),
bor3(!logi_bet, , ))
expect_equal(or3s(!logi_beu, , ),
bor3(!logi_beu, , ))
expect_equal(or3s(!logi_bev, , c < 0L),
bor3(!logi_bev, , c < 0L))
expect_equal(or3s(!logi_bew, , u < 1L),
bor3(!logi_bew, , u < 1L))
expect_equal(or3s(!logi_bex, , b < 9L),
bor3(!logi_bex, , b < 9L))
expect_equal(or3s(!logi_bey, logi_g, ),
bor3(!logi_bey, logi_g, ))
expect_equal(or3s(!logi_bez, logi_h, ),
bor3(!logi_bez, logi_h, ))
expect_equal(or3s(!logi_bfa, logi_q, ),
bor3(!logi_bfa, logi_q, ))
expect_equal(or3s(!logi_bfb, logi_u, k < 0L),
bor3(!logi_bfb, logi_u, k < 0L))
expect_equal(or3s(!logi_bfc, logi_a, x < 1L),
bor3(!logi_bfc, logi_a, x < 1L))
expect_equal(or3s(!logi_bfd, logi_h, u < 9L),
bor3(!logi_bfd, logi_h, u < 9L))
expect_equal(or3s(!logi_bfe, , ),
bor3(!logi_bfe, , ))
expect_equal(or3s(!logi_bff, , ),
bor3(!logi_bff, , ))
expect_equal(or3s(!logi_bfg, , ),
bor3(!logi_bfg, , ))
expect_equal(or3s(!logi_bfh, , y <= 0L),
bor3(!logi_bfh, , y <= 0L))
expect_equal(or3s(!logi_bfi, , z <= 1L),
bor3(!logi_bfi, , z <= 1L))
expect_equal(or3s(!logi_bfj, , r <= 9L),
bor3(!logi_bfj, , r <= 9L))
expect_equal(or3s(!logi_bfk, logi_h, ),
bor3(!logi_bfk, logi_h, ))
expect_equal(or3s(!logi_bfl, logi_p, ),
bor3(!logi_bfl, logi_p, ))
expect_equal(or3s(!logi_bfm, logi_y, ),
bor3(!logi_bfm, logi_y, ))
expect_equal(or3s(!logi_bfn, logi_z, e <= 0L),
bor3(!logi_bfn, logi_z, e <= 0L))
expect_equal(or3s(!logi_bfo, logi_c, b <= 1L),
bor3(!logi_bfo, logi_c, b <= 1L))
expect_equal(or3s(!logi_bfp, logi_l, b <= 9L),
bor3(!logi_bfp, logi_l, b <= 9L))
expect_equal(or3s(!logi_bfq, , ),
bor3(!logi_bfq, , ))
expect_equal(or3s(!logi_bfr, , ),
bor3(!logi_bfr, , ))
expect_equal(or3s(!logi_bfs, , ),
bor3(!logi_bfs, , ))
expect_equal(or3s(!logi_bft, , x == 0L),
bor3(!logi_bft, , x == 0L))
expect_equal(or3s(!logi_bfu, , h == 1L),
bor3(!logi_bfu, , h == 1L))
expect_equal(or3s(!logi_bfv, , t == 9L),
bor3(!logi_bfv, , t == 9L))
expect_equal(or3s(!logi_bfw, logi_p, ),
bor3(!logi_bfw, logi_p, ))
expect_equal(or3s(!logi_bfx, logi_v, ),
bor3(!logi_bfx, logi_v, ))
expect_equal(or3s(!logi_bfy, logi_y, ),
bor3(!logi_bfy, logi_y, ))
expect_equal(or3s(!logi_bfz, logi_v, o == 0L),
bor3(!logi_bfz, logi_v, o == 0L))
expect_equal(or3s(!logi_bga, logi_t, k == 1L),
bor3(!logi_bga, logi_t, k == 1L))
expect_equal(or3s(!logi_bgb, logi_d, s == 9L),
bor3(!logi_bgb, logi_d, s == 9L))
expect_equal(or3s(!logi_bgc, , ),
bor3(!logi_bgc, , ))
expect_equal(or3s(!logi_bgd, , ),
bor3(!logi_bgd, , ))
expect_equal(or3s(!logi_bge, , ),
bor3(!logi_bge, , ))
expect_equal(or3s(!logi_bgf, , x > 0L),
bor3(!logi_bgf, , x > 0L))
expect_equal(or3s(!logi_bgg, , b > 1L),
bor3(!logi_bgg, , b > 1L))
expect_equal(or3s(!logi_bgh, , h > 9L),
bor3(!logi_bgh, , h > 9L))
expect_equal(or3s(!logi_bgi, logi_i, ),
bor3(!logi_bgi, logi_i, ))
expect_equal(or3s(!logi_bgj, logi_f, ),
bor3(!logi_bgj, logi_f, ))
expect_equal(or3s(!logi_bgk, logi_j, ),
bor3(!logi_bgk, logi_j, ))
expect_equal(or3s(!logi_bgl, logi_o, n > 0L),
bor3(!logi_bgl, logi_o, n > 0L))
expect_equal(or3s(!logi_bgm, logi_h, s > 1L),
bor3(!logi_bgm, logi_h, s > 1L))
expect_equal(or3s(!logi_bgn, logi_w, s > 9L),
bor3(!logi_bgn, logi_w, s > 9L))
expect_equal(or3s(!logi_bgo, , ),
bor3(!logi_bgo, , ))
expect_equal(or3s(!logi_bgp, , ),
bor3(!logi_bgp, , ))
expect_equal(or3s(!logi_bgq, , ),
bor3(!logi_bgq, , ))
expect_equal(or3s(!logi_bgr, , u >= 0L),
bor3(!logi_bgr, , u >= 0L))
expect_equal(or3s(!logi_bgs, , f >= 1L),
bor3(!logi_bgs, , f >= 1L))
expect_equal(or3s(!logi_bgt, , a >= 9L),
bor3(!logi_bgt, , a >= 9L))
expect_equal(or3s(!logi_bgu, logi_f, ),
bor3(!logi_bgu, logi_f, ))
expect_equal(or3s(!logi_bgv, logi_a, ),
bor3(!logi_bgv, logi_a, ))
expect_equal(or3s(!logi_bgw, logi_z, ),
bor3(!logi_bgw, logi_z, ))
expect_equal(or3s(!logi_bgx, logi_p, i >= 0L),
bor3(!logi_bgx, logi_p, i >= 0L))
expect_equal(or3s(!logi_bgy, logi_u, m >= 1L),
bor3(!logi_bgy, logi_u, m >= 1L))
expect_equal(or3s(!logi_bgz, logi_d, k >= 9L),
bor3(!logi_bgz, logi_d, k >= 9L))
expect_equal(or3s(!logi_bha, , ),
bor3(!logi_bha, , ))
expect_equal(or3s(!logi_bhb, , ),
bor3(!logi_bhb, , ))
expect_equal(or3s(!logi_bhc, , ),
bor3(!logi_bhc, , ))
expect_equal(or3s(!logi_bhd, , logi_g),
bor3(!logi_bhd, , logi_g))
expect_equal(or3s(!logi_bhe, , logi_n),
bor3(!logi_bhe, , logi_n))
expect_equal(or3s(!logi_bhf, , logi_y),
bor3(!logi_bhf, , logi_y))
expect_equal(or3s(!logi_bhg, !logi_d, ),
bor3(!logi_bhg, !logi_d, ))
expect_equal(or3s(!logi_bhh, !logi_l, ),
bor3(!logi_bhh, !logi_l, ))
expect_equal(or3s(!logi_bhi, !logi_l, ),
bor3(!logi_bhi, !logi_l, ))
expect_equal(or3s(!logi_bhj, !logi_p, logi_q),
bor3(!logi_bhj, !logi_p, logi_q))
expect_equal(or3s(!logi_bhk, !logi_i, logi_x),
bor3(!logi_bhk, !logi_i, logi_x))
expect_equal(or3s(!logi_bhl, !logi_x, logi_i),
bor3(!logi_bhl, !logi_x, logi_i))
expect_equal(or3s(!logi_bhm, , ),
bor3(!logi_bhm, , ))
expect_equal(or3s(!logi_bhn, , ),
bor3(!logi_bhn, , ))
expect_equal(or3s(!logi_bho, , ),
bor3(!logi_bho, , ))
expect_equal(or3s(!logi_bhp, , !logi_a),
bor3(!logi_bhp, , !logi_a))
expect_equal(or3s(!logi_bhq, , !logi_l),
bor3(!logi_bhq, , !logi_l))
expect_equal(or3s(!logi_bhr, , !logi_x),
bor3(!logi_bhr, , !logi_x))
expect_equal(or3s(!logi_bhs, !logi_g, ),
bor3(!logi_bhs, !logi_g, ))
expect_equal(or3s(!logi_bht, !logi_b, ),
bor3(!logi_bht, !logi_b, ))
expect_equal(or3s(!logi_bhu, !logi_g, ),
bor3(!logi_bhu, !logi_g, ))
expect_equal(or3s(!logi_bhv, !logi_f, !logi_u),
bor3(!logi_bhv, !logi_f, !logi_u))
expect_equal(or3s(!logi_bhw, !logi_q, !logi_d),
bor3(!logi_bhw, !logi_q, !logi_d))
expect_equal(or3s(!logi_bhx, !logi_y, !logi_l),
bor3(!logi_bhx, !logi_y, !logi_l))
expect_equal(or3s(!logi_bhy, , ),
bor3(!logi_bhy, , ))
expect_equal(or3s(!logi_bhz, , ),
bor3(!logi_bhz, , ))
expect_equal(or3s(!logi_bia, , ),
bor3(!logi_bia, , ))
expect_equal(or3s(!logi_bib, , x != 0L),
bor3(!logi_bib, , x != 0L))
expect_equal(or3s(!logi_bic, , o != 1L),
bor3(!logi_bic, , o != 1L))
expect_equal(or3s(!logi_bid, , z != 9L),
bor3(!logi_bid, , z != 9L))
expect_equal(or3s(!logi_bie, !logi_k, ),
bor3(!logi_bie, !logi_k, ))
expect_equal(or3s(!logi_bif, !logi_x, ),
bor3(!logi_bif, !logi_x, ))
expect_equal(or3s(!logi_big, !logi_c, ),
bor3(!logi_big, !logi_c, ))
expect_equal(or3s(!logi_bih, !logi_q, c != 0L),
bor3(!logi_bih, !logi_q, c != 0L))
expect_equal(or3s(!logi_bii, !logi_p, w != 1L),
bor3(!logi_bii, !logi_p, w != 1L))
expect_equal(or3s(!logi_bij, !logi_p, u != 9L),
bor3(!logi_bij, !logi_p, u != 9L))
expect_equal(or3s(!logi_bik, , ),
bor3(!logi_bik, , ))
expect_equal(or3s(!logi_bil, , ),
bor3(!logi_bil, , ))
expect_equal(or3s(!logi_bim, , ),
bor3(!logi_bim, , ))
expect_equal(or3s(!logi_bin, , v %between% c(-1L, 1L)),
bor3(!logi_bin, , v %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bio, , n %between% c(-1L, 1L)),
bor3(!logi_bio, , n %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bip, , o %between% c(-1L, 1L)),
bor3(!logi_bip, , o %between% c(-1L, 1L)))
expect_equal(or3s(!logi_biq, !logi_k, ),
bor3(!logi_biq, !logi_k, ))
expect_equal(or3s(!logi_bir, !logi_a, ),
bor3(!logi_bir, !logi_a, ))
expect_equal(or3s(!logi_bis, !logi_k, ),
bor3(!logi_bis, !logi_k, ))
expect_equal(or3s(!logi_bit, !logi_t, q %between% c(-1L, 1L)),
bor3(!logi_bit, !logi_t, q %between% c(-1L, 1L)))
expect_equal(or3s(!logi_biu, !logi_s, z %between% c(-1L, 1L)),
bor3(!logi_biu, !logi_s, z %between% c(-1L, 1L)))
expect_equal(or3s(!logi_biv, !logi_s, m %between% c(-1L, 1L)),
bor3(!logi_biv, !logi_s, m %between% c(-1L, 1L)))
expect_equal(or3s(!logi_biw, , ),
bor3(!logi_biw, , ))
expect_equal(or3s(!logi_bix, , ),
bor3(!logi_bix, , ))
expect_equal(or3s(!logi_biy, , ),
bor3(!logi_biy, , ))
expect_equal(or3s(!logi_biz, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_biz, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bja, , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bja, , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bjb, , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bjb, , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bjc, !logi_d, ),
bor3(!logi_bjc, !logi_d, ))
expect_equal(or3s(!logi_bjd, !logi_c, ),
bor3(!logi_bjd, !logi_c, ))
expect_equal(or3s(!logi_bje, !logi_r, ),
bor3(!logi_bje, !logi_r, ))
expect_equal(or3s(!logi_bjf, !logi_x, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bjf, !logi_x, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bjg, !logi_c, u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bjg, !logi_c, u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bjh, !logi_a, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bjh, !logi_a, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bji, , ),
bor3(!logi_bji, , ))
expect_equal(or3s(!logi_bjj, , ),
bor3(!logi_bjj, , ))
expect_equal(or3s(!logi_bjk, , ),
bor3(!logi_bjk, , ))
expect_equal(or3s(!logi_bjl, , x %in% 1:4),
bor3(!logi_bjl, , x %in% 1:4))
expect_equal(or3s(!logi_bjm, , d %in% 1:4),
bor3(!logi_bjm, , d %in% 1:4))
expect_equal(or3s(!logi_bjn, , m %in% 1:4),
bor3(!logi_bjn, , m %in% 1:4))
expect_equal(or3s(!logi_bjo, !logi_e, ),
bor3(!logi_bjo, !logi_e, ))
expect_equal(or3s(!logi_bjp, !logi_r, ),
bor3(!logi_bjp, !logi_r, ))
expect_equal(or3s(!logi_bjq, !logi_m, ),
bor3(!logi_bjq, !logi_m, ))
expect_equal(or3s(!logi_bjr, !logi_z, z %in% 1:4),
bor3(!logi_bjr, !logi_z, z %in% 1:4))
expect_equal(or3s(!logi_bjs, !logi_z, o %in% 1:4),
bor3(!logi_bjs, !logi_z, o %in% 1:4))
expect_equal(or3s(!logi_bjt, !logi_e, q %in% 1:4),
bor3(!logi_bjt, !logi_e, q %in% 1:4))
expect_equal(or3s(!logi_bju, , ),
bor3(!logi_bju, , ))
expect_equal(or3s(!logi_bjv, , ),
bor3(!logi_bjv, , ))
expect_equal(or3s(!logi_bjw, , ),
bor3(!logi_bjw, , ))
expect_equal(or3s(!logi_bjx, , i < 0L),
bor3(!logi_bjx, , i < 0L))
expect_equal(or3s(!logi_bjy, , o < 1L),
bor3(!logi_bjy, , o < 1L))
expect_equal(or3s(!logi_bjz, , e < 9L),
bor3(!logi_bjz, , e < 9L))
expect_equal(or3s(!logi_bka, !logi_a, ),
bor3(!logi_bka, !logi_a, ))
expect_equal(or3s(!logi_bkb, !logi_m, ),
bor3(!logi_bkb, !logi_m, ))
expect_equal(or3s(!logi_bkc, !logi_b, ),
bor3(!logi_bkc, !logi_b, ))
expect_equal(or3s(!logi_bkd, !logi_y, r < 0L),
bor3(!logi_bkd, !logi_y, r < 0L))
expect_equal(or3s(!logi_bke, !logi_l, u < 1L),
bor3(!logi_bke, !logi_l, u < 1L))
expect_equal(or3s(!logi_bkf, !logi_y, l < 9L),
bor3(!logi_bkf, !logi_y, l < 9L))
expect_equal(or3s(!logi_bkg, , ),
bor3(!logi_bkg, , ))
expect_equal(or3s(!logi_bkh, , ),
bor3(!logi_bkh, , ))
expect_equal(or3s(!logi_bki, , ),
bor3(!logi_bki, , ))
expect_equal(or3s(!logi_bkj, , u <= 0L),
bor3(!logi_bkj, , u <= 0L))
expect_equal(or3s(!logi_bkk, , i <= 1L),
bor3(!logi_bkk, , i <= 1L))
expect_equal(or3s(!logi_bkl, , e <= 9L),
bor3(!logi_bkl, , e <= 9L))
expect_equal(or3s(!logi_bkm, !logi_l, ),
bor3(!logi_bkm, !logi_l, ))
expect_equal(or3s(!logi_bkn, !logi_v, ),
bor3(!logi_bkn, !logi_v, ))
expect_equal(or3s(!logi_bko, !logi_s, ),
bor3(!logi_bko, !logi_s, ))
expect_equal(or3s(!logi_bkp, !logi_n, o <= 0L),
bor3(!logi_bkp, !logi_n, o <= 0L))
expect_equal(or3s(!logi_bkq, !logi_u, s <= 1L),
bor3(!logi_bkq, !logi_u, s <= 1L))
expect_equal(or3s(!logi_bkr, !logi_d, m <= 9L),
bor3(!logi_bkr, !logi_d, m <= 9L))
expect_equal(or3s(!logi_bks, , ),
bor3(!logi_bks, , ))
expect_equal(or3s(!logi_bkt, , ),
bor3(!logi_bkt, , ))
expect_equal(or3s(!logi_bku, , ),
bor3(!logi_bku, , ))
expect_equal(or3s(!logi_bkv, , p == 0L),
bor3(!logi_bkv, , p == 0L))
expect_equal(or3s(!logi_bkw, , j == 1L),
bor3(!logi_bkw, , j == 1L))
expect_equal(or3s(!logi_bkx, , c == 9L),
bor3(!logi_bkx, , c == 9L))
expect_equal(or3s(!logi_bky, !logi_e, ),
bor3(!logi_bky, !logi_e, ))
expect_equal(or3s(!logi_bkz, !logi_r, ),
bor3(!logi_bkz, !logi_r, ))
expect_equal(or3s(!logi_bla, !logi_y, ),
bor3(!logi_bla, !logi_y, ))
expect_equal(or3s(!logi_blb, !logi_m, d == 0L),
bor3(!logi_blb, !logi_m, d == 0L))
expect_equal(or3s(!logi_blc, !logi_e, g == 1L),
bor3(!logi_blc, !logi_e, g == 1L))
expect_equal(or3s(!logi_bld, !logi_a, z == 9L),
bor3(!logi_bld, !logi_a, z == 9L))
expect_equal(or3s(!logi_ble, , ),
bor3(!logi_ble, , ))
expect_equal(or3s(!logi_blf, , ),
bor3(!logi_blf, , ))
expect_equal(or3s(!logi_blg, , ),
bor3(!logi_blg, , ))
expect_equal(or3s(!logi_blh, , j > 0L),
bor3(!logi_blh, , j > 0L))
expect_equal(or3s(!logi_bli, , s > 1L),
bor3(!logi_bli, , s > 1L))
expect_equal(or3s(!logi_blj, , t > 9L),
bor3(!logi_blj, , t > 9L))
expect_equal(or3s(!logi_blk, !logi_b, ),
bor3(!logi_blk, !logi_b, ))
expect_equal(or3s(!logi_bll, !logi_f, ),
bor3(!logi_bll, !logi_f, ))
expect_equal(or3s(!logi_blm, !logi_k, ),
bor3(!logi_blm, !logi_k, ))
expect_equal(or3s(!logi_bln, !logi_h, c > 0L),
bor3(!logi_bln, !logi_h, c > 0L))
expect_equal(or3s(!logi_blo, !logi_j, t > 1L),
bor3(!logi_blo, !logi_j, t > 1L))
expect_equal(or3s(!logi_blp, !logi_k, v > 9L),
bor3(!logi_blp, !logi_k, v > 9L))
expect_equal(or3s(!logi_blq, , ),
bor3(!logi_blq, , ))
expect_equal(or3s(!logi_blr, , ),
bor3(!logi_blr, , ))
expect_equal(or3s(!logi_bls, , ),
bor3(!logi_bls, , ))
expect_equal(or3s(!logi_blt, , n >= 0L),
bor3(!logi_blt, , n >= 0L))
expect_equal(or3s(!logi_blu, , e >= 1L),
bor3(!logi_blu, , e >= 1L))
expect_equal(or3s(!logi_blv, , j >= 9L),
bor3(!logi_blv, , j >= 9L))
expect_equal(or3s(!logi_blw, !logi_f, ),
bor3(!logi_blw, !logi_f, ))
expect_equal(or3s(!logi_blx, !logi_u, ),
bor3(!logi_blx, !logi_u, ))
expect_equal(or3s(!logi_bly, !logi_e, ),
bor3(!logi_bly, !logi_e, ))
expect_equal(or3s(!logi_blz, !logi_k, b >= 0L),
bor3(!logi_blz, !logi_k, b >= 0L))
expect_equal(or3s(!logi_bma, !logi_w, g >= 1L),
bor3(!logi_bma, !logi_w, g >= 1L))
expect_equal(or3s(!logi_bmb, !logi_d, f >= 9L),
bor3(!logi_bmb, !logi_d, f >= 9L))
expect_equal(or3s(!logi_bmc, , ),
bor3(!logi_bmc, , ))
expect_equal(or3s(!logi_bmd, , ),
bor3(!logi_bmd, , ))
expect_equal(or3s(!logi_bme, , ),
bor3(!logi_bme, , ))
expect_equal(or3s(!logi_bmf, , logi_u),
bor3(!logi_bmf, , logi_u))
expect_equal(or3s(!logi_bmg, , logi_y),
bor3(!logi_bmg, , logi_y))
expect_equal(or3s(!logi_bmh, , logi_u),
bor3(!logi_bmh, , logi_u))
expect_equal(or3s(!logi_bmi, p != 0L, ),
bor3(!logi_bmi, p != 0L, ))
expect_equal(or3s(!logi_bmj, p != 1L, ),
bor3(!logi_bmj, p != 1L, ))
expect_equal(or3s(!logi_bmk, z != 9L, ),
bor3(!logi_bmk, z != 9L, ))
expect_equal(or3s(!logi_bml, g != 0L, logi_c),
bor3(!logi_bml, g != 0L, logi_c))
expect_equal(or3s(!logi_bmm, c != 1L, logi_e),
bor3(!logi_bmm, c != 1L, logi_e))
expect_equal(or3s(!logi_bmn, d != 9L, logi_k),
bor3(!logi_bmn, d != 9L, logi_k))
expect_equal(or3s(!logi_bmo, , ),
bor3(!logi_bmo, , ))
expect_equal(or3s(!logi_bmp, , ),
bor3(!logi_bmp, , ))
expect_equal(or3s(!logi_bmq, , ),
bor3(!logi_bmq, , ))
expect_equal(or3s(!logi_bmr, , !logi_c),
bor3(!logi_bmr, , !logi_c))
expect_equal(or3s(!logi_bms, , !logi_y),
bor3(!logi_bms, , !logi_y))
expect_equal(or3s(!logi_bmt, , !logi_f),
bor3(!logi_bmt, , !logi_f))
expect_equal(or3s(!logi_bmu, z != 0L, ),
bor3(!logi_bmu, z != 0L, ))
expect_equal(or3s(!logi_bmv, a != 1L, ),
bor3(!logi_bmv, a != 1L, ))
expect_equal(or3s(!logi_bmw, y != 9L, ),
bor3(!logi_bmw, y != 9L, ))
expect_equal(or3s(!logi_bmx, r != 0L, !logi_n),
bor3(!logi_bmx, r != 0L, !logi_n))
expect_equal(or3s(!logi_bmy, h != 1L, !logi_u),
bor3(!logi_bmy, h != 1L, !logi_u))
expect_equal(or3s(!logi_bmz, e != 9L, !logi_c),
bor3(!logi_bmz, e != 9L, !logi_c))
expect_equal(or3s(!logi_bna, , ),
bor3(!logi_bna, , ))
expect_equal(or3s(!logi_bnb, , ),
bor3(!logi_bnb, , ))
expect_equal(or3s(!logi_bnc, , ),
bor3(!logi_bnc, , ))
expect_equal(or3s(!logi_bnd, , n != 0L),
bor3(!logi_bnd, , n != 0L))
expect_equal(or3s(!logi_bne, , y != 1L),
bor3(!logi_bne, , y != 1L))
expect_equal(or3s(!logi_bnf, , k != 9L),
bor3(!logi_bnf, , k != 9L))
expect_equal(or3s(!logi_bng, d != 0L, ),
bor3(!logi_bng, d != 0L, ))
expect_equal(or3s(!logi_bnh, t != 1L, ),
bor3(!logi_bnh, t != 1L, ))
expect_equal(or3s(!logi_bni, m != 9L, ),
bor3(!logi_bni, m != 9L, ))
expect_equal(or3s(!logi_bnj, m != 0L, v != 0L),
bor3(!logi_bnj, m != 0L, v != 0L))
expect_equal(or3s(!logi_bnk, v != 1L, z != 1L),
bor3(!logi_bnk, v != 1L, z != 1L))
expect_equal(or3s(!logi_bnl, o != 9L, n != 9L),
bor3(!logi_bnl, o != 9L, n != 9L))
expect_equal(or3s(!logi_bnm, , ),
bor3(!logi_bnm, , ))
expect_equal(or3s(!logi_bnn, , ),
bor3(!logi_bnn, , ))
expect_equal(or3s(!logi_bno, , ),
bor3(!logi_bno, , ))
expect_equal(or3s(!logi_bnp, , a %between% c(-1L, 1L)),
bor3(!logi_bnp, , a %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bnq, , e %between% c(-1L, 1L)),
bor3(!logi_bnq, , e %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bnr, , i %between% c(-1L, 1L)),
bor3(!logi_bnr, , i %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bns, w != 0L, ),
bor3(!logi_bns, w != 0L, ))
expect_equal(or3s(!logi_bnt, n != 1L, ),
bor3(!logi_bnt, n != 1L, ))
expect_equal(or3s(!logi_bnu, s != 9L, ),
bor3(!logi_bnu, s != 9L, ))
expect_equal(or3s(!logi_bnv, j != 0L, b %between% c(-1L, 1L)),
bor3(!logi_bnv, j != 0L, b %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bnw, c != 1L, l %between% c(-1L, 1L)),
bor3(!logi_bnw, c != 1L, l %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bnx, q != 9L, v %between% c(-1L, 1L)),
bor3(!logi_bnx, q != 9L, v %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bny, , ),
bor3(!logi_bny, , ))
expect_equal(or3s(!logi_bnz, , ),
bor3(!logi_bnz, , ))
expect_equal(or3s(!logi_boa, , ),
bor3(!logi_boa, , ))
expect_equal(or3s(!logi_bob, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bob, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_boc, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_boc, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bod, , q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bod, , q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_boe, t != 0L, ),
bor3(!logi_boe, t != 0L, ))
expect_equal(or3s(!logi_bof, z != 1L, ),
bor3(!logi_bof, z != 1L, ))
expect_equal(or3s(!logi_bog, t != 9L, ),
bor3(!logi_bog, t != 9L, ))
expect_equal(or3s(!logi_boh, k != 0L, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_boh, k != 0L, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_boi, r != 1L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_boi, r != 1L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_boj, v != 9L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_boj, v != 9L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bok, , ),
bor3(!logi_bok, , ))
expect_equal(or3s(!logi_bol, , ),
bor3(!logi_bol, , ))
expect_equal(or3s(!logi_bom, , ),
bor3(!logi_bom, , ))
expect_equal(or3s(!logi_bon, , b %in% 1:4),
bor3(!logi_bon, , b %in% 1:4))
expect_equal(or3s(!logi_boo, , u %in% 1:4),
bor3(!logi_boo, , u %in% 1:4))
expect_equal(or3s(!logi_bop, , v %in% 1:4),
bor3(!logi_bop, , v %in% 1:4))
expect_equal(or3s(!logi_boq, i != 0L, ),
bor3(!logi_boq, i != 0L, ))
expect_equal(or3s(!logi_bor, v != 1L, ),
bor3(!logi_bor, v != 1L, ))
expect_equal(or3s(!logi_bos, t != 9L, ),
bor3(!logi_bos, t != 9L, ))
expect_equal(or3s(!logi_bot, o != 0L, f %in% 1:4),
bor3(!logi_bot, o != 0L, f %in% 1:4))
expect_equal(or3s(!logi_bou, l != 1L, p %in% 1:4),
bor3(!logi_bou, l != 1L, p %in% 1:4))
expect_equal(or3s(!logi_bov, r != 9L, o %in% 1:4),
bor3(!logi_bov, r != 9L, o %in% 1:4))
expect_equal(or3s(!logi_bow, , ),
bor3(!logi_bow, , ))
expect_equal(or3s(!logi_box, , ),
bor3(!logi_box, , ))
expect_equal(or3s(!logi_boy, , ),
bor3(!logi_boy, , ))
expect_equal(or3s(!logi_boz, , y < 0L),
bor3(!logi_boz, , y < 0L))
expect_equal(or3s(!logi_bpa, , e < 1L),
bor3(!logi_bpa, , e < 1L))
expect_equal(or3s(!logi_bpb, , e < 9L),
bor3(!logi_bpb, , e < 9L))
expect_equal(or3s(!logi_bpc, g != 0L, ),
bor3(!logi_bpc, g != 0L, ))
expect_equal(or3s(!logi_bpd, q != 1L, ),
bor3(!logi_bpd, q != 1L, ))
expect_equal(or3s(!logi_bpe, m != 9L, ),
bor3(!logi_bpe, m != 9L, ))
expect_equal(or3s(!logi_bpf, t != 0L, i < 0L),
bor3(!logi_bpf, t != 0L, i < 0L))
expect_equal(or3s(!logi_bpg, u != 1L, u < 1L),
bor3(!logi_bpg, u != 1L, u < 1L))
expect_equal(or3s(!logi_bph, h != 9L, i < 9L),
bor3(!logi_bph, h != 9L, i < 9L))
expect_equal(or3s(!logi_bpi, , ),
bor3(!logi_bpi, , ))
expect_equal(or3s(!logi_bpj, , ),
bor3(!logi_bpj, , ))
expect_equal(or3s(!logi_bpk, , ),
bor3(!logi_bpk, , ))
expect_equal(or3s(!logi_bpl, , f <= 0L),
bor3(!logi_bpl, , f <= 0L))
expect_equal(or3s(!logi_bpm, , s <= 1L),
bor3(!logi_bpm, , s <= 1L))
expect_equal(or3s(!logi_bpn, , p <= 9L),
bor3(!logi_bpn, , p <= 9L))
expect_equal(or3s(!logi_bpo, f != 0L, ),
bor3(!logi_bpo, f != 0L, ))
expect_equal(or3s(!logi_bpp, f != 1L, ),
bor3(!logi_bpp, f != 1L, ))
expect_equal(or3s(!logi_bpq, y != 9L, ),
bor3(!logi_bpq, y != 9L, ))
expect_equal(or3s(!logi_bpr, y != 0L, c <= 0L),
bor3(!logi_bpr, y != 0L, c <= 0L))
expect_equal(or3s(!logi_bps, e != 1L, j <= 1L),
bor3(!logi_bps, e != 1L, j <= 1L))
expect_equal(or3s(!logi_bpt, a != 9L, r <= 9L),
bor3(!logi_bpt, a != 9L, r <= 9L))
expect_equal(or3s(!logi_bpu, , ),
bor3(!logi_bpu, , ))
expect_equal(or3s(!logi_bpv, , ),
bor3(!logi_bpv, , ))
expect_equal(or3s(!logi_bpw, , ),
bor3(!logi_bpw, , ))
expect_equal(or3s(!logi_bpx, , p == 0L),
bor3(!logi_bpx, , p == 0L))
expect_equal(or3s(!logi_bpy, , q == 1L),
bor3(!logi_bpy, , q == 1L))
expect_equal(or3s(!logi_bpz, , z == 9L),
bor3(!logi_bpz, , z == 9L))
expect_equal(or3s(!logi_bqa, g != 0L, ),
bor3(!logi_bqa, g != 0L, ))
expect_equal(or3s(!logi_bqb, b != 1L, ),
bor3(!logi_bqb, b != 1L, ))
expect_equal(or3s(!logi_bqc, d != 9L, ),
bor3(!logi_bqc, d != 9L, ))
expect_equal(or3s(!logi_bqd, j != 0L, j == 0L),
bor3(!logi_bqd, j != 0L, j == 0L))
expect_equal(or3s(!logi_bqe, t != 1L, y == 1L),
bor3(!logi_bqe, t != 1L, y == 1L))
expect_equal(or3s(!logi_bqf, z != 9L, n == 9L),
bor3(!logi_bqf, z != 9L, n == 9L))
expect_equal(or3s(!logi_bqg, , ),
bor3(!logi_bqg, , ))
expect_equal(or3s(!logi_bqh, , ),
bor3(!logi_bqh, , ))
expect_equal(or3s(!logi_bqi, , ),
bor3(!logi_bqi, , ))
expect_equal(or3s(!logi_bqj, , q > 0L),
bor3(!logi_bqj, , q > 0L))
expect_equal(or3s(!logi_bqk, , w > 1L),
bor3(!logi_bqk, , w > 1L))
expect_equal(or3s(!logi_bql, , a > 9L),
bor3(!logi_bql, , a > 9L))
expect_equal(or3s(!logi_bqm, r != 0L, ),
bor3(!logi_bqm, r != 0L, ))
expect_equal(or3s(!logi_bqn, w != 1L, ),
bor3(!logi_bqn, w != 1L, ))
expect_equal(or3s(!logi_bqo, u != 9L, ),
bor3(!logi_bqo, u != 9L, ))
expect_equal(or3s(!logi_bqp, x != 0L, e > 0L),
bor3(!logi_bqp, x != 0L, e > 0L))
expect_equal(or3s(!logi_bqq, r != 1L, s > 1L),
bor3(!logi_bqq, r != 1L, s > 1L))
expect_equal(or3s(!logi_bqr, e != 9L, r > 9L),
bor3(!logi_bqr, e != 9L, r > 9L))
expect_equal(or3s(!logi_bqs, , ),
bor3(!logi_bqs, , ))
expect_equal(or3s(!logi_bqt, , ),
bor3(!logi_bqt, , ))
expect_equal(or3s(!logi_bqu, , ),
bor3(!logi_bqu, , ))
expect_equal(or3s(!logi_bqv, , k >= 0L),
bor3(!logi_bqv, , k >= 0L))
expect_equal(or3s(!logi_bqw, , s >= 1L),
bor3(!logi_bqw, , s >= 1L))
expect_equal(or3s(!logi_bqx, , m >= 9L),
bor3(!logi_bqx, , m >= 9L))
expect_equal(or3s(!logi_bqy, c != 0L, ),
bor3(!logi_bqy, c != 0L, ))
expect_equal(or3s(!logi_bqz, v != 1L, ),
bor3(!logi_bqz, v != 1L, ))
expect_equal(or3s(!logi_bra, x != 9L, ),
bor3(!logi_bra, x != 9L, ))
expect_equal(or3s(!logi_brb, t != 0L, y >= 0L),
bor3(!logi_brb, t != 0L, y >= 0L))
expect_equal(or3s(!logi_brc, q != 1L, f >= 1L),
bor3(!logi_brc, q != 1L, f >= 1L))
expect_equal(or3s(!logi_brd, z != 9L, t >= 9L),
bor3(!logi_brd, z != 9L, t >= 9L))
expect_equal(or3s(!logi_bre, , ),
bor3(!logi_bre, , ))
expect_equal(or3s(!logi_brf, , ),
bor3(!logi_brf, , ))
expect_equal(or3s(!logi_brg, , ),
bor3(!logi_brg, , ))
expect_equal(or3s(!logi_brh, , logi_c),
bor3(!logi_brh, , logi_c))
expect_equal(or3s(!logi_bri, , logi_g),
bor3(!logi_bri, , logi_g))
expect_equal(or3s(!logi_brj, , logi_u),
bor3(!logi_brj, , logi_u))
expect_equal(or3s(!logi_brk, p %between% c(-1L, 1L), ),
bor3(!logi_brk, p %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_brl, y %between% c(-1L, 1L), ),
bor3(!logi_brl, y %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_brm, d %between% c(-1L, 1L), ),
bor3(!logi_brm, d %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_brn, e %between% c(-1L, 1L), logi_l),
bor3(!logi_brn, e %between% c(-1L, 1L), logi_l))
expect_equal(or3s(!logi_bro, l %between% c(-1L, 1L), logi_n),
bor3(!logi_bro, l %between% c(-1L, 1L), logi_n))
expect_equal(or3s(!logi_brp, m %between% c(-1L, 1L), logi_w),
bor3(!logi_brp, m %between% c(-1L, 1L), logi_w))
expect_equal(or3s(!logi_brq, , ),
bor3(!logi_brq, , ))
expect_equal(or3s(!logi_brr, , ),
bor3(!logi_brr, , ))
expect_equal(or3s(!logi_brs, , ),
bor3(!logi_brs, , ))
expect_equal(or3s(!logi_brt, , !logi_a),
bor3(!logi_brt, , !logi_a))
expect_equal(or3s(!logi_bru, , !logi_w),
bor3(!logi_bru, , !logi_w))
expect_equal(or3s(!logi_brv, , !logi_x),
bor3(!logi_brv, , !logi_x))
expect_equal(or3s(!logi_brw, o %between% c(-1L, 1L), ),
bor3(!logi_brw, o %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_brx, v %between% c(-1L, 1L), ),
bor3(!logi_brx, v %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bry, c %between% c(-1L, 1L), ),
bor3(!logi_bry, c %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_brz, l %between% c(-1L, 1L), !logi_e),
bor3(!logi_brz, l %between% c(-1L, 1L), !logi_e))
expect_equal(or3s(!logi_bsa, n %between% c(-1L, 1L), !logi_i),
bor3(!logi_bsa, n %between% c(-1L, 1L), !logi_i))
expect_equal(or3s(!logi_bsb, d %between% c(-1L, 1L), !logi_v),
bor3(!logi_bsb, d %between% c(-1L, 1L), !logi_v))
expect_equal(or3s(!logi_bsc, , ),
bor3(!logi_bsc, , ))
expect_equal(or3s(!logi_bsd, , ),
bor3(!logi_bsd, , ))
expect_equal(or3s(!logi_bse, , ),
bor3(!logi_bse, , ))
expect_equal(or3s(!logi_bsf, , u != 0L),
bor3(!logi_bsf, , u != 0L))
expect_equal(or3s(!logi_bsg, , h != 1L),
bor3(!logi_bsg, , h != 1L))
expect_equal(or3s(!logi_bsh, , d != 9L),
bor3(!logi_bsh, , d != 9L))
expect_equal(or3s(!logi_bsi, h %between% c(-1L, 1L), ),
bor3(!logi_bsi, h %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bsj, s %between% c(-1L, 1L), ),
bor3(!logi_bsj, s %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bsk, y %between% c(-1L, 1L), ),
bor3(!logi_bsk, y %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bsl, m %between% c(-1L, 1L), i != 0L),
bor3(!logi_bsl, m %between% c(-1L, 1L), i != 0L))
expect_equal(or3s(!logi_bsm, h %between% c(-1L, 1L), v != 1L),
bor3(!logi_bsm, h %between% c(-1L, 1L), v != 1L))
expect_equal(or3s(!logi_bsn, e %between% c(-1L, 1L), i != 9L),
bor3(!logi_bsn, e %between% c(-1L, 1L), i != 9L))
expect_equal(or3s(!logi_bso, , ),
bor3(!logi_bso, , ))
expect_equal(or3s(!logi_bsp, , ),
bor3(!logi_bsp, , ))
expect_equal(or3s(!logi_bsq, , ),
bor3(!logi_bsq, , ))
expect_equal(or3s(!logi_bsr, , o %between% c(-1L, 1L)),
bor3(!logi_bsr, , o %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bss, , u %between% c(-1L, 1L)),
bor3(!logi_bss, , u %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bst, , d %between% c(-1L, 1L)),
bor3(!logi_bst, , d %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bsu, c %between% c(-1L, 1L), ),
bor3(!logi_bsu, c %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bsv, q %between% c(-1L, 1L), ),
bor3(!logi_bsv, q %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bsw, k %between% c(-1L, 1L), ),
bor3(!logi_bsw, k %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bsx, l %between% c(-1L, 1L), e %between% c(-1L, 1L)),
bor3(!logi_bsx, l %between% c(-1L, 1L), e %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bsy, e %between% c(-1L, 1L), i %between% c(-1L, 1L)),
bor3(!logi_bsy, e %between% c(-1L, 1L), i %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bsz, b %between% c(-1L, 1L), b %between% c(-1L, 1L)),
bor3(!logi_bsz, b %between% c(-1L, 1L), b %between% c(-1L, 1L)))
expect_equal(or3s(!logi_bta, , ),
bor3(!logi_bta, , ))
expect_equal(or3s(!logi_btb, , ),
bor3(!logi_btb, , ))
expect_equal(or3s(!logi_btc, , ),
bor3(!logi_btc, , ))
expect_equal(or3s(!logi_btd, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_btd, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_bte, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_bte, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_btf, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_btf, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_btg, g %between% c(-1L, 1L), ),
bor3(!logi_btg, g %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bth, m %between% c(-1L, 1L), ),
bor3(!logi_bth, m %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bti, i %between% c(-1L, 1L), ),
bor3(!logi_bti, i %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_btj, j %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_btj, j %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_btk, w %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_btk, w %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_btl, b %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_btl, b %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_btm, , ),
bor3(!logi_btm, , ))
expect_equal(or3s(!logi_btn, , ),
bor3(!logi_btn, , ))
expect_equal(or3s(!logi_bto, , ),
bor3(!logi_bto, , ))
expect_equal(or3s(!logi_btp, , r %in% 1:4),
bor3(!logi_btp, , r %in% 1:4))
expect_equal(or3s(!logi_btq, , j %in% 1:4),
bor3(!logi_btq, , j %in% 1:4))
expect_equal(or3s(!logi_btr, , x %in% 1:4),
bor3(!logi_btr, , x %in% 1:4))
expect_equal(or3s(!logi_bts, a %between% c(-1L, 1L), ),
bor3(!logi_bts, a %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_btt, x %between% c(-1L, 1L), ),
bor3(!logi_btt, x %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_btu, v %between% c(-1L, 1L), ),
bor3(!logi_btu, v %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_btv, u %between% c(-1L, 1L), t %in% 1:4),
bor3(!logi_btv, u %between% c(-1L, 1L), t %in% 1:4))
expect_equal(or3s(!logi_btw, d %between% c(-1L, 1L), y %in% 1:4),
bor3(!logi_btw, d %between% c(-1L, 1L), y %in% 1:4))
expect_equal(or3s(!logi_btx, s %between% c(-1L, 1L), f %in% 1:4),
bor3(!logi_btx, s %between% c(-1L, 1L), f %in% 1:4))
expect_equal(or3s(!logi_bty, , ),
bor3(!logi_bty, , ))
expect_equal(or3s(!logi_btz, , ),
bor3(!logi_btz, , ))
expect_equal(or3s(!logi_bua, , ),
bor3(!logi_bua, , ))
expect_equal(or3s(!logi_bub, , g < 0L),
bor3(!logi_bub, , g < 0L))
expect_equal(or3s(!logi_buc, , i < 1L),
bor3(!logi_buc, , i < 1L))
expect_equal(or3s(!logi_bud, , o < 9L),
bor3(!logi_bud, , o < 9L))
expect_equal(or3s(!logi_bue, h %between% c(-1L, 1L), ),
bor3(!logi_bue, h %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_buf, x %between% c(-1L, 1L), ),
bor3(!logi_buf, x %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bug, v %between% c(-1L, 1L), ),
bor3(!logi_bug, v %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_buh, m %between% c(-1L, 1L), n < 0L),
bor3(!logi_buh, m %between% c(-1L, 1L), n < 0L))
expect_equal(or3s(!logi_bui, c %between% c(-1L, 1L), d < 1L),
bor3(!logi_bui, c %between% c(-1L, 1L), d < 1L))
expect_equal(or3s(!logi_buj, a %between% c(-1L, 1L), i < 9L),
bor3(!logi_buj, a %between% c(-1L, 1L), i < 9L))
expect_equal(or3s(!logi_buk, , ),
bor3(!logi_buk, , ))
expect_equal(or3s(!logi_bul, , ),
bor3(!logi_bul, , ))
expect_equal(or3s(!logi_bum, , ),
bor3(!logi_bum, , ))
expect_equal(or3s(!logi_bun, , w <= 0L),
bor3(!logi_bun, , w <= 0L))
expect_equal(or3s(!logi_buo, , b <= 1L),
bor3(!logi_buo, , b <= 1L))
expect_equal(or3s(!logi_bup, , i <= 9L),
bor3(!logi_bup, , i <= 9L))
expect_equal(or3s(!logi_buq, n %between% c(-1L, 1L), ),
bor3(!logi_buq, n %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bur, x %between% c(-1L, 1L), ),
bor3(!logi_bur, x %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bus, j %between% c(-1L, 1L), ),
bor3(!logi_bus, j %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_but, y %between% c(-1L, 1L), o <= 0L),
bor3(!logi_but, y %between% c(-1L, 1L), o <= 0L))
expect_equal(or3s(!logi_buu, p %between% c(-1L, 1L), f <= 1L),
bor3(!logi_buu, p %between% c(-1L, 1L), f <= 1L))
expect_equal(or3s(!logi_buv, o %between% c(-1L, 1L), d <= 9L),
bor3(!logi_buv, o %between% c(-1L, 1L), d <= 9L))
expect_equal(or3s(!logi_buw, , ),
bor3(!logi_buw, , ))
expect_equal(or3s(!logi_bux, , ),
bor3(!logi_bux, , ))
expect_equal(or3s(!logi_buy, , ),
bor3(!logi_buy, , ))
expect_equal(or3s(!logi_buz, , s == 0L),
bor3(!logi_buz, , s == 0L))
expect_equal(or3s(!logi_bva, , m == 1L),
bor3(!logi_bva, , m == 1L))
expect_equal(or3s(!logi_bvb, , l == 9L),
bor3(!logi_bvb, , l == 9L))
expect_equal(or3s(!logi_bvc, x %between% c(-1L, 1L), ),
bor3(!logi_bvc, x %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bvd, r %between% c(-1L, 1L), ),
bor3(!logi_bvd, r %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bve, n %between% c(-1L, 1L), ),
bor3(!logi_bve, n %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bvf, o %between% c(-1L, 1L), s == 0L),
bor3(!logi_bvf, o %between% c(-1L, 1L), s == 0L))
expect_equal(or3s(!logi_bvg, d %between% c(-1L, 1L), y == 1L),
bor3(!logi_bvg, d %between% c(-1L, 1L), y == 1L))
expect_equal(or3s(!logi_bvh, m %between% c(-1L, 1L), q == 9L),
bor3(!logi_bvh, m %between% c(-1L, 1L), q == 9L))
expect_equal(or3s(!logi_bvi, , ),
bor3(!logi_bvi, , ))
expect_equal(or3s(!logi_bvj, , ),
bor3(!logi_bvj, , ))
expect_equal(or3s(!logi_bvk, , ),
bor3(!logi_bvk, , ))
expect_equal(or3s(!logi_bvl, , s > 0L),
bor3(!logi_bvl, , s > 0L))
expect_equal(or3s(!logi_bvm, , d > 1L),
bor3(!logi_bvm, , d > 1L))
expect_equal(or3s(!logi_bvn, , g > 9L),
bor3(!logi_bvn, , g > 9L))
expect_equal(or3s(!logi_bvo, x %between% c(-1L, 1L), ),
bor3(!logi_bvo, x %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bvp, k %between% c(-1L, 1L), ),
bor3(!logi_bvp, k %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bvq, x %between% c(-1L, 1L), ),
bor3(!logi_bvq, x %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bvr, j %between% c(-1L, 1L), n > 0L),
bor3(!logi_bvr, j %between% c(-1L, 1L), n > 0L))
expect_equal(or3s(!logi_bvs, r %between% c(-1L, 1L), s > 1L),
bor3(!logi_bvs, r %between% c(-1L, 1L), s > 1L))
expect_equal(or3s(!logi_bvt, q %between% c(-1L, 1L), y > 9L),
bor3(!logi_bvt, q %between% c(-1L, 1L), y > 9L))
expect_equal(or3s(!logi_bvu, , ),
bor3(!logi_bvu, , ))
expect_equal(or3s(!logi_bvv, , ),
bor3(!logi_bvv, , ))
expect_equal(or3s(!logi_bvw, , ),
bor3(!logi_bvw, , ))
expect_equal(or3s(!logi_bvx, , l >= 0L),
bor3(!logi_bvx, , l >= 0L))
expect_equal(or3s(!logi_bvy, , r >= 1L),
bor3(!logi_bvy, , r >= 1L))
expect_equal(or3s(!logi_bvz, , q >= 9L),
bor3(!logi_bvz, , q >= 9L))
expect_equal(or3s(!logi_bwa, n %between% c(-1L, 1L), ),
bor3(!logi_bwa, n %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bwb, o %between% c(-1L, 1L), ),
bor3(!logi_bwb, o %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bwc, l %between% c(-1L, 1L), ),
bor3(!logi_bwc, l %between% c(-1L, 1L), ))
expect_equal(or3s(!logi_bwd, z %between% c(-1L, 1L), v >= 0L),
bor3(!logi_bwd, z %between% c(-1L, 1L), v >= 0L))
expect_equal(or3s(!logi_bwe, d %between% c(-1L, 1L), p >= 1L),
bor3(!logi_bwe, d %between% c(-1L, 1L), p >= 1L))
expect_equal(or3s(!logi_bwf, w %between% c(-1L, 1L), r >= 9L),
bor3(!logi_bwf, w %between% c(-1L, 1L), r >= 9L))
expect_equal(or3s(!logi_bwg, , ),
bor3(!logi_bwg, , ))
expect_equal(or3s(!logi_bwh, , ),
bor3(!logi_bwh, , ))
expect_equal(or3s(!logi_bwi, , ),
bor3(!logi_bwi, , ))
expect_equal(or3s(!logi_bwj, , logi_b),
bor3(!logi_bwj, , logi_b))
expect_equal(or3s(!logi_bwk, , logi_j),
bor3(!logi_bwk, , logi_j))
expect_equal(or3s(!logi_bwl, , logi_r),
bor3(!logi_bwl, , logi_r))
expect_equal(or3s(!logi_bwm, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_bwm, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_bwn, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_bwn, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_bwo, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_bwo, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_bwp, o %in% c(4L, -3L, 2L, 7L, 8L), logi_d),
bor3(!logi_bwp, o %in% c(4L, -3L, 2L, 7L, 8L), logi_d))
expect_equal(or3s(!logi_bwq, s %in% c(4L, -3L, 2L, 7L, 8L), logi_m),
bor3(!logi_bwq, s %in% c(4L, -3L, 2L, 7L, 8L), logi_m))
expect_equal(or3s(!logi_bwr, k %in% c(4L, -3L, 2L, 7L, 8L), logi_m),
bor3(!logi_bwr, k %in% c(4L, -3L, 2L, 7L, 8L), logi_m))
expect_equal(or3s(!logi_bws, , ),
bor3(!logi_bws, , ))
expect_equal(or3s(!logi_bwt, , ),
bor3(!logi_bwt, , ))
expect_equal(or3s(!logi_bwu, , ),
bor3(!logi_bwu, , ))
expect_equal(or3s(!logi_bwv, , logi_u),
bor3(!logi_bwv, , logi_u))
expect_equal(or3s(!logi_bww, , logi_v),
bor3(!logi_bww, , logi_v))
expect_equal(or3s(!logi_bwx, , logi_y),
bor3(!logi_bwx, , logi_y))
expect_equal(or3s(!logi_bwy, r %in% 1:4, ),
bor3(!logi_bwy, r %in% 1:4, ))
expect_equal(or3s(!logi_bwz, t %in% 1:4, ),
bor3(!logi_bwz, t %in% 1:4, ))
expect_equal(or3s(!logi_bxa, k %in% 1:4, ),
bor3(!logi_bxa, k %in% 1:4, ))
expect_equal(or3s(!logi_bxb, q %in% 1:4, logi_w),
bor3(!logi_bxb, q %in% 1:4, logi_w))
expect_equal(or3s(!logi_bxc, k %in% 1:4, logi_f),
bor3(!logi_bxc, k %in% 1:4, logi_f))
expect_equal(or3s(!logi_bxd, u %in% 1:4, logi_r),
bor3(!logi_bxd, u %in% 1:4, logi_r))
expect_equal(or3s(!logi_bxe, , ),
bor3(!logi_bxe, , ))
expect_equal(or3s(!logi_bxf, , ),
bor3(!logi_bxf, , ))
expect_equal(or3s(!logi_bxg, , ),
bor3(!logi_bxg, , ))
expect_equal(or3s(!logi_bxh, , !logi_w),
bor3(!logi_bxh, , !logi_w))
expect_equal(or3s(!logi_bxi, , !logi_c),
bor3(!logi_bxi, , !logi_c))
expect_equal(or3s(!logi_bxj, , !logi_k),
bor3(!logi_bxj, , !logi_k))
expect_equal(or3s(!logi_bxk, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_bxk, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_bxl, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_bxl, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_bxm, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_bxm, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_bxn, y %in% c(4L, -3L, 2L, 7L, 8L), !logi_e),
bor3(!logi_bxn, y %in% c(4L, -3L, 2L, 7L, 8L), !logi_e))
expect_equal(or3s(!logi_bxo, k %in% c(4L, -3L, 2L, 7L, 8L), !logi_z),
bor3(!logi_bxo, k %in% c(4L, -3L, 2L, 7L, 8L), !logi_z))
expect_equal(or3s(!logi_bxp, n %in% c(4L, -3L, 2L, 7L, 8L), !logi_n),
bor3(!logi_bxp, n %in% c(4L, -3L, 2L, 7L, 8L), !logi_n))
expect_equal(or3s(!logi_bxq, , ),
bor3(!logi_bxq, , ))
expect_equal(or3s(!logi_bxr, , ),
bor3(!logi_bxr, , ))
expect_equal(or3s(!logi_bxs, , ),
bor3(!logi_bxs, , ))
expect_equal(or3s(!logi_bxt, , !logi_g),
bor3(!logi_bxt, , !logi_g))
expect_equal(or3s(!logi_bxu, , !logi_n),
bor3(!logi_bxu, , !logi_n))
expect_equal(or3s(!logi_bxv, , !logi_m),
bor3(!logi_bxv, , !logi_m))
expect_equal(or3s(!logi_bxw, y %in% 1:4, ),
bor3(!logi_bxw, y %in% 1:4, ))
expect_equal(or3s(!logi_bxx, c %in% 1:4, ),
bor3(!logi_bxx, c %in% 1:4, ))
expect_equal(or3s(!logi_bxy, l %in% 1:4, ),
bor3(!logi_bxy, l %in% 1:4, ))
expect_equal(or3s(!logi_bxz, y %in% 1:4, !logi_o),
bor3(!logi_bxz, y %in% 1:4, !logi_o))
expect_equal(or3s(!logi_bya, i %in% 1:4, !logi_h),
bor3(!logi_bya, i %in% 1:4, !logi_h))
expect_equal(or3s(!logi_byb, k %in% 1:4, !logi_a),
bor3(!logi_byb, k %in% 1:4, !logi_a))
expect_equal(or3s(!logi_byc, , ),
bor3(!logi_byc, , ))
expect_equal(or3s(!logi_byd, , ),
bor3(!logi_byd, , ))
expect_equal(or3s(!logi_bye, , ),
bor3(!logi_bye, , ))
expect_equal(or3s(!logi_byf, , i != 0L),
bor3(!logi_byf, , i != 0L))
expect_equal(or3s(!logi_byg, , g != 1L),
bor3(!logi_byg, , g != 1L))
expect_equal(or3s(!logi_byh, , o != 9L),
bor3(!logi_byh, , o != 9L))
expect_equal(or3s(!logi_byi, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_byi, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_byj, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_byj, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_byk, l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_byk, l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_byl, w %in% c(4L, -3L, 2L, 7L, 8L), i != 0L),
bor3(!logi_byl, w %in% c(4L, -3L, 2L, 7L, 8L), i != 0L))
expect_equal(or3s(!logi_bym, d %in% c(4L, -3L, 2L, 7L, 8L), j != 1L),
bor3(!logi_bym, d %in% c(4L, -3L, 2L, 7L, 8L), j != 1L))
expect_equal(or3s(!logi_byn, g %in% c(4L, -3L, 2L, 7L, 8L), k != 9L),
bor3(!logi_byn, g %in% c(4L, -3L, 2L, 7L, 8L), k != 9L))
expect_equal(or3s(!logi_byo, , ),
bor3(!logi_byo, , ))
expect_equal(or3s(!logi_byp, , ),
bor3(!logi_byp, , ))
expect_equal(or3s(!logi_byq, , ),
bor3(!logi_byq, , ))
expect_equal(or3s(!logi_byr, , y != 0L),
bor3(!logi_byr, , y != 0L))
expect_equal(or3s(!logi_bys, , b != 1L),
bor3(!logi_bys, , b != 1L))
expect_equal(or3s(!logi_byt, , h != 9L),
bor3(!logi_byt, , h != 9L))
expect_equal(or3s(!logi_byu, t %in% 1:4, ),
bor3(!logi_byu, t %in% 1:4, ))
expect_equal(or3s(!logi_byv, t %in% 1:4, ),
bor3(!logi_byv, t %in% 1:4, ))
expect_equal(or3s(!logi_byw, r %in% 1:4, ),
bor3(!logi_byw, r %in% 1:4, ))
expect_equal(or3s(!logi_byx, v %in% 1:4, f != 0L),
bor3(!logi_byx, v %in% 1:4, f != 0L))
expect_equal(or3s(!logi_byy, r %in% 1:4, k != 1L),
bor3(!logi_byy, r %in% 1:4, k != 1L))
expect_equal(or3s(!logi_byz, k %in% 1:4, k != 9L),
bor3(!logi_byz, k %in% 1:4, k != 9L))
expect_equal(or3s(!logi_ca, , ),
bor3(!logi_ca, , ))
expect_equal(or3s(!logi_cb, , ),
bor3(!logi_cb, , ))
expect_equal(or3s(!logi_cc, , ),
bor3(!logi_cc, , ))
expect_equal(or3s(!logi_cd, , r %between% c(-1L, 1L)),
bor3(!logi_cd, , r %between% c(-1L, 1L)))
expect_equal(or3s(!logi_ce, , g %between% c(-1L, 1L)),
bor3(!logi_ce, , g %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cf, , b %between% c(-1L, 1L)),
bor3(!logi_cf, , b %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cg, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cg, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_ch, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ch, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_ci, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ci, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cj, k %in% c(4L, -3L, 2L, 7L, 8L), r %between% c(-1L, 1L)),
bor3(!logi_cj, k %in% c(4L, -3L, 2L, 7L, 8L), r %between% c(-1L, 1L)))
expect_equal(or3s(!logi_ck, f %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)),
bor3(!logi_ck, f %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cl, a %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)),
bor3(!logi_cl, a %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cm, , ),
bor3(!logi_cm, , ))
expect_equal(or3s(!logi_cn, , ),
bor3(!logi_cn, , ))
expect_equal(or3s(!logi_co, , ),
bor3(!logi_co, , ))
expect_equal(or3s(!logi_cp, , r %between% c(-1L, 1L)),
bor3(!logi_cp, , r %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cq, , y %between% c(-1L, 1L)),
bor3(!logi_cq, , y %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cr, , w %between% c(-1L, 1L)),
bor3(!logi_cr, , w %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cs, g %in% 1:4, ),
bor3(!logi_cs, g %in% 1:4, ))
expect_equal(or3s(!logi_ct, o %in% 1:4, ),
bor3(!logi_ct, o %in% 1:4, ))
expect_equal(or3s(!logi_cu, x %in% 1:4, ),
bor3(!logi_cu, x %in% 1:4, ))
expect_equal(or3s(!logi_cv, z %in% 1:4, t %between% c(-1L, 1L)),
bor3(!logi_cv, z %in% 1:4, t %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cw, m %in% 1:4, b %between% c(-1L, 1L)),
bor3(!logi_cw, m %in% 1:4, b %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cx, z %in% 1:4, o %between% c(-1L, 1L)),
bor3(!logi_cx, z %in% 1:4, o %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cy, , ),
bor3(!logi_cy, , ))
expect_equal(or3s(!logi_cz, , ),
bor3(!logi_cz, , ))
expect_equal(or3s(!logi_caa, , ),
bor3(!logi_caa, , ))
expect_equal(or3s(!logi_cab, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cab, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cac, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cac, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cad, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cad, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cae, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cae, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_caf, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_caf, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cag, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cag, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cah, j %in% c(4L, -3L, 2L, 7L, 8L), j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cah, j %in% c(4L, -3L, 2L, 7L, 8L), j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cai, y %in% c(4L, -3L, 2L, 7L, 8L), w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cai, y %in% c(4L, -3L, 2L, 7L, 8L), w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_caj, b %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_caj, b %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cak, , ),
bor3(!logi_cak, , ))
expect_equal(or3s(!logi_cal, , ),
bor3(!logi_cal, , ))
expect_equal(or3s(!logi_cam, , ),
bor3(!logi_cam, , ))
expect_equal(or3s(!logi_can, , p %in% 1:4),
bor3(!logi_can, , p %in% 1:4))
expect_equal(or3s(!logi_cao, , f %in% 1:4),
bor3(!logi_cao, , f %in% 1:4))
expect_equal(or3s(!logi_cap, , x %in% 1:4),
bor3(!logi_cap, , x %in% 1:4))
expect_equal(or3s(!logi_caq, k %in% 1:4, ),
bor3(!logi_caq, k %in% 1:4, ))
expect_equal(or3s(!logi_car, i %in% 1:4, ),
bor3(!logi_car, i %in% 1:4, ))
expect_equal(or3s(!logi_cas, q %in% 1:4, ),
bor3(!logi_cas, q %in% 1:4, ))
expect_equal(or3s(!logi_cat, z %in% 1:4, z %in% 1:4),
bor3(!logi_cat, z %in% 1:4, z %in% 1:4))
expect_equal(or3s(!logi_cau, c %in% 1:4, c %in% 1:4),
bor3(!logi_cau, c %in% 1:4, c %in% 1:4))
expect_equal(or3s(!logi_cav, t %in% 1:4, l %in% 1:4),
bor3(!logi_cav, t %in% 1:4, l %in% 1:4))
expect_equal(or3s(!logi_caw, , ),
bor3(!logi_caw, , ))
expect_equal(or3s(!logi_cax, , ),
bor3(!logi_cax, , ))
expect_equal(or3s(!logi_cay, , ),
bor3(!logi_cay, , ))
expect_equal(or3s(!logi_caz, , s < 0L),
bor3(!logi_caz, , s < 0L))
expect_equal(or3s(!logi_cba, , z < 1L),
bor3(!logi_cba, , z < 1L))
expect_equal(or3s(!logi_cbb, , b < 9L),
bor3(!logi_cbb, , b < 9L))
expect_equal(or3s(!logi_cbc, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cbc, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cbd, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cbd, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cbe, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cbe, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cbf, t %in% c(4L, -3L, 2L, 7L, 8L), c < 0L),
bor3(!logi_cbf, t %in% c(4L, -3L, 2L, 7L, 8L), c < 0L))
expect_equal(or3s(!logi_cbg, h %in% c(4L, -3L, 2L, 7L, 8L), b < 1L),
bor3(!logi_cbg, h %in% c(4L, -3L, 2L, 7L, 8L), b < 1L))
expect_equal(or3s(!logi_cbh, h %in% c(4L, -3L, 2L, 7L, 8L), u < 9L),
bor3(!logi_cbh, h %in% c(4L, -3L, 2L, 7L, 8L), u < 9L))
expect_equal(or3s(!logi_cbi, , ),
bor3(!logi_cbi, , ))
expect_equal(or3s(!logi_cbj, , ),
bor3(!logi_cbj, , ))
expect_equal(or3s(!logi_cbk, , ),
bor3(!logi_cbk, , ))
expect_equal(or3s(!logi_cbl, , a < 0L),
bor3(!logi_cbl, , a < 0L))
expect_equal(or3s(!logi_cbm, , w < 1L),
bor3(!logi_cbm, , w < 1L))
expect_equal(or3s(!logi_cbn, , d < 9L),
bor3(!logi_cbn, , d < 9L))
expect_equal(or3s(!logi_cbo, q %in% 1:4, ),
bor3(!logi_cbo, q %in% 1:4, ))
expect_equal(or3s(!logi_cbp, w %in% 1:4, ),
bor3(!logi_cbp, w %in% 1:4, ))
expect_equal(or3s(!logi_cbq, r %in% 1:4, ),
bor3(!logi_cbq, r %in% 1:4, ))
expect_equal(or3s(!logi_cbr, x %in% 1:4, u < 0L),
bor3(!logi_cbr, x %in% 1:4, u < 0L))
expect_equal(or3s(!logi_cbs, l %in% 1:4, c < 1L),
bor3(!logi_cbs, l %in% 1:4, c < 1L))
expect_equal(or3s(!logi_cbt, h %in% 1:4, q < 9L),
bor3(!logi_cbt, h %in% 1:4, q < 9L))
expect_equal(or3s(!logi_cbu, , ),
bor3(!logi_cbu, , ))
expect_equal(or3s(!logi_cbv, , ),
bor3(!logi_cbv, , ))
expect_equal(or3s(!logi_cbw, , ),
bor3(!logi_cbw, , ))
expect_equal(or3s(!logi_cbx, , d <= 0L),
bor3(!logi_cbx, , d <= 0L))
expect_equal(or3s(!logi_cby, , m <= 1L),
bor3(!logi_cby, , m <= 1L))
expect_equal(or3s(!logi_cbz, , h <= 9L),
bor3(!logi_cbz, , h <= 9L))
expect_equal(or3s(!logi_cca, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cca, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_ccb, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ccb, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_ccc, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ccc, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_ccd, h %in% c(4L, -3L, 2L, 7L, 8L), q <= 0L),
bor3(!logi_ccd, h %in% c(4L, -3L, 2L, 7L, 8L), q <= 0L))
expect_equal(or3s(!logi_cce, h %in% c(4L, -3L, 2L, 7L, 8L), f <= 1L),
bor3(!logi_cce, h %in% c(4L, -3L, 2L, 7L, 8L), f <= 1L))
expect_equal(or3s(!logi_ccf, r %in% c(4L, -3L, 2L, 7L, 8L), a <= 9L),
bor3(!logi_ccf, r %in% c(4L, -3L, 2L, 7L, 8L), a <= 9L))
expect_equal(or3s(!logi_ccg, , ),
bor3(!logi_ccg, , ))
expect_equal(or3s(!logi_cch, , ),
bor3(!logi_cch, , ))
expect_equal(or3s(!logi_cci, , ),
bor3(!logi_cci, , ))
expect_equal(or3s(!logi_ccj, , e <= 0L),
bor3(!logi_ccj, , e <= 0L))
expect_equal(or3s(!logi_cck, , w <= 1L),
bor3(!logi_cck, , w <= 1L))
expect_equal(or3s(!logi_ccl, , a <= 9L),
bor3(!logi_ccl, , a <= 9L))
expect_equal(or3s(!logi_ccm, w %in% 1:4, ),
bor3(!logi_ccm, w %in% 1:4, ))
expect_equal(or3s(!logi_ccn, k %in% 1:4, ),
bor3(!logi_ccn, k %in% 1:4, ))
expect_equal(or3s(!logi_cco, s %in% 1:4, ),
bor3(!logi_cco, s %in% 1:4, ))
expect_equal(or3s(!logi_ccp, q %in% 1:4, t <= 0L),
bor3(!logi_ccp, q %in% 1:4, t <= 0L))
expect_equal(or3s(!logi_ccq, u %in% 1:4, r <= 1L),
bor3(!logi_ccq, u %in% 1:4, r <= 1L))
expect_equal(or3s(!logi_ccr, o %in% 1:4, i <= 9L),
bor3(!logi_ccr, o %in% 1:4, i <= 9L))
expect_equal(or3s(!logi_ccs, , ),
bor3(!logi_ccs, , ))
expect_equal(or3s(!logi_cct, , ),
bor3(!logi_cct, , ))
expect_equal(or3s(!logi_ccu, , ),
bor3(!logi_ccu, , ))
expect_equal(or3s(!logi_ccv, , v == 0L),
bor3(!logi_ccv, , v == 0L))
expect_equal(or3s(!logi_ccw, , j == 1L),
bor3(!logi_ccw, , j == 1L))
expect_equal(or3s(!logi_ccx, , b == 9L),
bor3(!logi_ccx, , b == 9L))
expect_equal(or3s(!logi_ccy, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ccy, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_ccz, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ccz, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cda, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cda, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cdb, i %in% c(4L, -3L, 2L, 7L, 8L), h == 0L),
bor3(!logi_cdb, i %in% c(4L, -3L, 2L, 7L, 8L), h == 0L))
expect_equal(or3s(!logi_cdc, f %in% c(4L, -3L, 2L, 7L, 8L), c == 1L),
bor3(!logi_cdc, f %in% c(4L, -3L, 2L, 7L, 8L), c == 1L))
expect_equal(or3s(!logi_cdd, x %in% c(4L, -3L, 2L, 7L, 8L), d == 9L),
bor3(!logi_cdd, x %in% c(4L, -3L, 2L, 7L, 8L), d == 9L))
expect_equal(or3s(!logi_cde, , ),
bor3(!logi_cde, , ))
expect_equal(or3s(!logi_cdf, , ),
bor3(!logi_cdf, , ))
expect_equal(or3s(!logi_cdg, , ),
bor3(!logi_cdg, , ))
expect_equal(or3s(!logi_cdh, , i == 0L),
bor3(!logi_cdh, , i == 0L))
expect_equal(or3s(!logi_cdi, , h == 1L),
bor3(!logi_cdi, , h == 1L))
expect_equal(or3s(!logi_cdj, , c == 9L),
bor3(!logi_cdj, , c == 9L))
expect_equal(or3s(!logi_cdk, l %in% 1:4, ),
bor3(!logi_cdk, l %in% 1:4, ))
expect_equal(or3s(!logi_cdl, x %in% 1:4, ),
bor3(!logi_cdl, x %in% 1:4, ))
expect_equal(or3s(!logi_cdm, a %in% 1:4, ),
bor3(!logi_cdm, a %in% 1:4, ))
expect_equal(or3s(!logi_cdn, k %in% 1:4, p == 0L),
bor3(!logi_cdn, k %in% 1:4, p == 0L))
expect_equal(or3s(!logi_cdo, u %in% 1:4, j == 1L),
bor3(!logi_cdo, u %in% 1:4, j == 1L))
expect_equal(or3s(!logi_cdp, p %in% 1:4, t == 9L),
bor3(!logi_cdp, p %in% 1:4, t == 9L))
expect_equal(or3s(!logi_cdq, , ),
bor3(!logi_cdq, , ))
expect_equal(or3s(!logi_cdr, , ),
bor3(!logi_cdr, , ))
expect_equal(or3s(!logi_cds, , ),
bor3(!logi_cds, , ))
expect_equal(or3s(!logi_cdt, , y > 0L),
bor3(!logi_cdt, , y > 0L))
expect_equal(or3s(!logi_cdu, , o > 1L),
bor3(!logi_cdu, , o > 1L))
expect_equal(or3s(!logi_cdv, , r > 9L),
bor3(!logi_cdv, , r > 9L))
expect_equal(or3s(!logi_cdw, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cdw, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cdx, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cdx, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cdy, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cdy, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cdz, v %in% c(4L, -3L, 2L, 7L, 8L), x > 0L),
bor3(!logi_cdz, v %in% c(4L, -3L, 2L, 7L, 8L), x > 0L))
expect_equal(or3s(!logi_cea, c %in% c(4L, -3L, 2L, 7L, 8L), w > 1L),
bor3(!logi_cea, c %in% c(4L, -3L, 2L, 7L, 8L), w > 1L))
expect_equal(or3s(!logi_ceb, w %in% c(4L, -3L, 2L, 7L, 8L), i > 9L),
bor3(!logi_ceb, w %in% c(4L, -3L, 2L, 7L, 8L), i > 9L))
expect_equal(or3s(!logi_cec, , ),
bor3(!logi_cec, , ))
expect_equal(or3s(!logi_ced, , ),
bor3(!logi_ced, , ))
expect_equal(or3s(!logi_cee, , ),
bor3(!logi_cee, , ))
expect_equal(or3s(!logi_cef, , c > 0L),
bor3(!logi_cef, , c > 0L))
expect_equal(or3s(!logi_ceg, , k > 1L),
bor3(!logi_ceg, , k > 1L))
expect_equal(or3s(!logi_ceh, , b > 9L),
bor3(!logi_ceh, , b > 9L))
expect_equal(or3s(!logi_cei, b %in% 1:4, ),
bor3(!logi_cei, b %in% 1:4, ))
expect_equal(or3s(!logi_cej, k %in% 1:4, ),
bor3(!logi_cej, k %in% 1:4, ))
expect_equal(or3s(!logi_cek, k %in% 1:4, ),
bor3(!logi_cek, k %in% 1:4, ))
expect_equal(or3s(!logi_cel, m %in% 1:4, i > 0L),
bor3(!logi_cel, m %in% 1:4, i > 0L))
expect_equal(or3s(!logi_cem, b %in% 1:4, c > 1L),
bor3(!logi_cem, b %in% 1:4, c > 1L))
expect_equal(or3s(!logi_cen, v %in% 1:4, b > 9L),
bor3(!logi_cen, v %in% 1:4, b > 9L))
expect_equal(or3s(!logi_ceo, , ),
bor3(!logi_ceo, , ))
expect_equal(or3s(!logi_cep, , ),
bor3(!logi_cep, , ))
expect_equal(or3s(!logi_ceq, , ),
bor3(!logi_ceq, , ))
expect_equal(or3s(!logi_cer, , b >= 0L),
bor3(!logi_cer, , b >= 0L))
expect_equal(or3s(!logi_ces, , y >= 1L),
bor3(!logi_ces, , y >= 1L))
expect_equal(or3s(!logi_cet, , s >= 9L),
bor3(!logi_cet, , s >= 9L))
expect_equal(or3s(!logi_ceu, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_ceu, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cev, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cev, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cew, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(!logi_cew, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(!logi_cex, e %in% c(4L, -3L, 2L, 7L, 8L), r >= 0L),
bor3(!logi_cex, e %in% c(4L, -3L, 2L, 7L, 8L), r >= 0L))
expect_equal(or3s(!logi_cey, s %in% c(4L, -3L, 2L, 7L, 8L), k >= 1L),
bor3(!logi_cey, s %in% c(4L, -3L, 2L, 7L, 8L), k >= 1L))
expect_equal(or3s(!logi_cez, z %in% c(4L, -3L, 2L, 7L, 8L), l >= 9L),
bor3(!logi_cez, z %in% c(4L, -3L, 2L, 7L, 8L), l >= 9L))
expect_equal(or3s(!logi_cfa, , ),
bor3(!logi_cfa, , ))
expect_equal(or3s(!logi_cfb, , ),
bor3(!logi_cfb, , ))
expect_equal(or3s(!logi_cfc, , ),
bor3(!logi_cfc, , ))
expect_equal(or3s(!logi_cfd, , p >= 0L),
bor3(!logi_cfd, , p >= 0L))
expect_equal(or3s(!logi_cfe, , y >= 1L),
bor3(!logi_cfe, , y >= 1L))
expect_equal(or3s(!logi_cff, , u >= 9L),
bor3(!logi_cff, , u >= 9L))
expect_equal(or3s(!logi_cfg, b %in% 1:4, ),
bor3(!logi_cfg, b %in% 1:4, ))
expect_equal(or3s(!logi_cfh, q %in% 1:4, ),
bor3(!logi_cfh, q %in% 1:4, ))
expect_equal(or3s(!logi_cfi, j %in% 1:4, ),
bor3(!logi_cfi, j %in% 1:4, ))
expect_equal(or3s(!logi_cfj, b %in% 1:4, x >= 0L),
bor3(!logi_cfj, b %in% 1:4, x >= 0L))
expect_equal(or3s(!logi_cfk, x %in% 1:4, k >= 1L),
bor3(!logi_cfk, x %in% 1:4, k >= 1L))
expect_equal(or3s(!logi_cfl, d %in% 1:4, g >= 9L),
bor3(!logi_cfl, d %in% 1:4, g >= 9L))
expect_equal(or3s(!logi_cfm, , ),
bor3(!logi_cfm, , ))
expect_equal(or3s(!logi_cfn, , ),
bor3(!logi_cfn, , ))
expect_equal(or3s(!logi_cfo, , ),
bor3(!logi_cfo, , ))
expect_equal(or3s(!logi_cfp, , logi_q),
bor3(!logi_cfp, , logi_q))
expect_equal(or3s(!logi_cfq, , logi_o),
bor3(!logi_cfq, , logi_o))
expect_equal(or3s(!logi_cfr, , logi_s),
bor3(!logi_cfr, , logi_s))
expect_equal(or3s(!logi_cfs, b < 0L, ),
bor3(!logi_cfs, b < 0L, ))
expect_equal(or3s(!logi_cft, g < 1L, ),
bor3(!logi_cft, g < 1L, ))
expect_equal(or3s(!logi_cfu, a < 9L, ),
bor3(!logi_cfu, a < 9L, ))
expect_equal(or3s(!logi_cfv, o < 0L, logi_m),
bor3(!logi_cfv, o < 0L, logi_m))
expect_equal(or3s(!logi_cfw, v < 1L, logi_w),
bor3(!logi_cfw, v < 1L, logi_w))
expect_equal(or3s(!logi_cfx, i < 9L, logi_h),
bor3(!logi_cfx, i < 9L, logi_h))
expect_equal(or3s(!logi_cfy, , ),
bor3(!logi_cfy, , ))
expect_equal(or3s(!logi_cfz, , ),
bor3(!logi_cfz, , ))
expect_equal(or3s(!logi_cga, , ),
bor3(!logi_cga, , ))
expect_equal(or3s(!logi_cgb, , !logi_z),
bor3(!logi_cgb, , !logi_z))
expect_equal(or3s(!logi_cgc, , !logi_l),
bor3(!logi_cgc, , !logi_l))
expect_equal(or3s(!logi_cgd, , !logi_y),
bor3(!logi_cgd, , !logi_y))
expect_equal(or3s(!logi_cge, w < 0L, ),
bor3(!logi_cge, w < 0L, ))
expect_equal(or3s(!logi_cgf, z < 1L, ),
bor3(!logi_cgf, z < 1L, ))
expect_equal(or3s(!logi_cgg, n < 9L, ),
bor3(!logi_cgg, n < 9L, ))
expect_equal(or3s(!logi_cgh, q < 0L, !logi_e),
bor3(!logi_cgh, q < 0L, !logi_e))
expect_equal(or3s(!logi_cgi, l < 1L, !logi_t),
bor3(!logi_cgi, l < 1L, !logi_t))
expect_equal(or3s(!logi_cgj, t < 9L, !logi_h),
bor3(!logi_cgj, t < 9L, !logi_h))
expect_equal(or3s(!logi_cgk, , ),
bor3(!logi_cgk, , ))
expect_equal(or3s(!logi_cgl, , ),
bor3(!logi_cgl, , ))
expect_equal(or3s(!logi_cgm, , ),
bor3(!logi_cgm, , ))
expect_equal(or3s(!logi_cgn, , z != 0L),
bor3(!logi_cgn, , z != 0L))
expect_equal(or3s(!logi_cgo, , c != 1L),
bor3(!logi_cgo, , c != 1L))
expect_equal(or3s(!logi_cgp, , e != 9L),
bor3(!logi_cgp, , e != 9L))
expect_equal(or3s(!logi_cgq, e < 0L, ),
bor3(!logi_cgq, e < 0L, ))
expect_equal(or3s(!logi_cgr, t < 1L, ),
bor3(!logi_cgr, t < 1L, ))
expect_equal(or3s(!logi_cgs, c < 9L, ),
bor3(!logi_cgs, c < 9L, ))
expect_equal(or3s(!logi_cgt, x < 0L, k != 0L),
bor3(!logi_cgt, x < 0L, k != 0L))
expect_equal(or3s(!logi_cgu, s < 1L, q != 1L),
bor3(!logi_cgu, s < 1L, q != 1L))
expect_equal(or3s(!logi_cgv, w < 9L, h != 9L),
bor3(!logi_cgv, w < 9L, h != 9L))
expect_equal(or3s(!logi_cgw, , ),
bor3(!logi_cgw, , ))
expect_equal(or3s(!logi_cgx, , ),
bor3(!logi_cgx, , ))
expect_equal(or3s(!logi_cgy, , ),
bor3(!logi_cgy, , ))
expect_equal(or3s(!logi_cgz, , k %between% c(-1L, 1L)),
bor3(!logi_cgz, , k %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cha, , m %between% c(-1L, 1L)),
bor3(!logi_cha, , m %between% c(-1L, 1L)))
expect_equal(or3s(!logi_chb, , u %between% c(-1L, 1L)),
bor3(!logi_chb, , u %between% c(-1L, 1L)))
expect_equal(or3s(!logi_chc, c < 0L, ),
bor3(!logi_chc, c < 0L, ))
expect_equal(or3s(!logi_chd, u < 1L, ),
bor3(!logi_chd, u < 1L, ))
expect_equal(or3s(!logi_che, a < 9L, ),
bor3(!logi_che, a < 9L, ))
expect_equal(or3s(!logi_chf, r < 0L, m %between% c(-1L, 1L)),
bor3(!logi_chf, r < 0L, m %between% c(-1L, 1L)))
expect_equal(or3s(!logi_chg, t < 1L, h %between% c(-1L, 1L)),
bor3(!logi_chg, t < 1L, h %between% c(-1L, 1L)))
expect_equal(or3s(!logi_chh, c < 9L, k %between% c(-1L, 1L)),
bor3(!logi_chh, c < 9L, k %between% c(-1L, 1L)))
expect_equal(or3s(!logi_chi, , ),
bor3(!logi_chi, , ))
expect_equal(or3s(!logi_chj, , ),
bor3(!logi_chj, , ))
expect_equal(or3s(!logi_chk, , ),
bor3(!logi_chk, , ))
expect_equal(or3s(!logi_chl, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_chl, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_chm, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_chm, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_chn, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_chn, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cho, h < 0L, ),
bor3(!logi_cho, h < 0L, ))
expect_equal(or3s(!logi_chp, n < 1L, ),
bor3(!logi_chp, n < 1L, ))
expect_equal(or3s(!logi_chq, m < 9L, ),
bor3(!logi_chq, m < 9L, ))
expect_equal(or3s(!logi_chr, c < 0L, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_chr, c < 0L, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_chs, o < 1L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_chs, o < 1L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cht, e < 9L, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cht, e < 9L, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_chu, , ),
bor3(!logi_chu, , ))
expect_equal(or3s(!logi_chv, , ),
bor3(!logi_chv, , ))
expect_equal(or3s(!logi_chw, , ),
bor3(!logi_chw, , ))
expect_equal(or3s(!logi_chx, , y %in% 1:4),
bor3(!logi_chx, , y %in% 1:4))
expect_equal(or3s(!logi_chy, , m %in% 1:4),
bor3(!logi_chy, , m %in% 1:4))
expect_equal(or3s(!logi_chz, , r %in% 1:4),
bor3(!logi_chz, , r %in% 1:4))
expect_equal(or3s(!logi_cia, a < 0L, ),
bor3(!logi_cia, a < 0L, ))
expect_equal(or3s(!logi_cib, m < 1L, ),
bor3(!logi_cib, m < 1L, ))
expect_equal(or3s(!logi_cic, n < 9L, ),
bor3(!logi_cic, n < 9L, ))
expect_equal(or3s(!logi_cid, r < 0L, f %in% 1:4),
bor3(!logi_cid, r < 0L, f %in% 1:4))
expect_equal(or3s(!logi_cie, v < 1L, z %in% 1:4),
bor3(!logi_cie, v < 1L, z %in% 1:4))
expect_equal(or3s(!logi_cif, o < 9L, v %in% 1:4),
bor3(!logi_cif, o < 9L, v %in% 1:4))
expect_equal(or3s(!logi_cig, , ),
bor3(!logi_cig, , ))
expect_equal(or3s(!logi_cih, , ),
bor3(!logi_cih, , ))
expect_equal(or3s(!logi_cii, , ),
bor3(!logi_cii, , ))
expect_equal(or3s(!logi_cij, , m < 0L),
bor3(!logi_cij, , m < 0L))
expect_equal(or3s(!logi_cik, , b < 1L),
bor3(!logi_cik, , b < 1L))
expect_equal(or3s(!logi_cil, , j < 9L),
bor3(!logi_cil, , j < 9L))
expect_equal(or3s(!logi_cim, y < 0L, ),
bor3(!logi_cim, y < 0L, ))
expect_equal(or3s(!logi_cin, t < 1L, ),
bor3(!logi_cin, t < 1L, ))
expect_equal(or3s(!logi_cio, w < 9L, ),
bor3(!logi_cio, w < 9L, ))
expect_equal(or3s(!logi_cip, p < 0L, k < 0L),
bor3(!logi_cip, p < 0L, k < 0L))
expect_equal(or3s(!logi_ciq, a < 1L, f < 1L),
bor3(!logi_ciq, a < 1L, f < 1L))
expect_equal(or3s(!logi_cir, l < 9L, v < 9L),
bor3(!logi_cir, l < 9L, v < 9L))
expect_equal(or3s(!logi_cis, , ),
bor3(!logi_cis, , ))
expect_equal(or3s(!logi_cit, , ),
bor3(!logi_cit, , ))
expect_equal(or3s(!logi_ciu, , ),
bor3(!logi_ciu, , ))
expect_equal(or3s(!logi_civ, , e <= 0L),
bor3(!logi_civ, , e <= 0L))
expect_equal(or3s(!logi_ciw, , k <= 1L),
bor3(!logi_ciw, , k <= 1L))
expect_equal(or3s(!logi_cix, , q <= 9L),
bor3(!logi_cix, , q <= 9L))
expect_equal(or3s(!logi_ciy, u < 0L, ),
bor3(!logi_ciy, u < 0L, ))
expect_equal(or3s(!logi_ciz, i < 1L, ),
bor3(!logi_ciz, i < 1L, ))
expect_equal(or3s(!logi_cja, b < 9L, ),
bor3(!logi_cja, b < 9L, ))
expect_equal(or3s(!logi_cjb, k < 0L, t <= 0L),
bor3(!logi_cjb, k < 0L, t <= 0L))
expect_equal(or3s(!logi_cjc, u < 1L, s <= 1L),
bor3(!logi_cjc, u < 1L, s <= 1L))
expect_equal(or3s(!logi_cjd, u < 9L, n <= 9L),
bor3(!logi_cjd, u < 9L, n <= 9L))
expect_equal(or3s(!logi_cje, , ),
bor3(!logi_cje, , ))
expect_equal(or3s(!logi_cjf, , ),
bor3(!logi_cjf, , ))
expect_equal(or3s(!logi_cjg, , ),
bor3(!logi_cjg, , ))
expect_equal(or3s(!logi_cjh, , s == 0L),
bor3(!logi_cjh, , s == 0L))
expect_equal(or3s(!logi_cji, , n == 1L),
bor3(!logi_cji, , n == 1L))
expect_equal(or3s(!logi_cjj, , q == 9L),
bor3(!logi_cjj, , q == 9L))
expect_equal(or3s(!logi_cjk, l < 0L, ),
bor3(!logi_cjk, l < 0L, ))
expect_equal(or3s(!logi_cjl, f < 1L, ),
bor3(!logi_cjl, f < 1L, ))
expect_equal(or3s(!logi_cjm, s < 9L, ),
bor3(!logi_cjm, s < 9L, ))
expect_equal(or3s(!logi_cjn, t < 0L, z == 0L),
bor3(!logi_cjn, t < 0L, z == 0L))
expect_equal(or3s(!logi_cjo, j < 1L, n == 1L),
bor3(!logi_cjo, j < 1L, n == 1L))
expect_equal(or3s(!logi_cjp, n < 9L, j == 9L),
bor3(!logi_cjp, n < 9L, j == 9L))
expect_equal(or3s(!logi_cjq, , ),
bor3(!logi_cjq, , ))
expect_equal(or3s(!logi_cjr, , ),
bor3(!logi_cjr, , ))
expect_equal(or3s(!logi_cjs, , ),
bor3(!logi_cjs, , ))
expect_equal(or3s(!logi_cjt, , e > 0L),
bor3(!logi_cjt, , e > 0L))
expect_equal(or3s(!logi_cju, , h > 1L),
bor3(!logi_cju, , h > 1L))
expect_equal(or3s(!logi_cjv, , s > 9L),
bor3(!logi_cjv, , s > 9L))
expect_equal(or3s(!logi_cjw, a < 0L, ),
bor3(!logi_cjw, a < 0L, ))
expect_equal(or3s(!logi_cjx, v < 1L, ),
bor3(!logi_cjx, v < 1L, ))
expect_equal(or3s(!logi_cjy, a < 9L, ),
bor3(!logi_cjy, a < 9L, ))
expect_equal(or3s(!logi_cjz, h < 0L, i > 0L),
bor3(!logi_cjz, h < 0L, i > 0L))
expect_equal(or3s(!logi_cka, x < 1L, s > 1L),
bor3(!logi_cka, x < 1L, s > 1L))
expect_equal(or3s(!logi_ckb, q < 9L, f > 9L),
bor3(!logi_ckb, q < 9L, f > 9L))
expect_equal(or3s(!logi_ckc, , ),
bor3(!logi_ckc, , ))
expect_equal(or3s(!logi_ckd, , ),
bor3(!logi_ckd, , ))
expect_equal(or3s(!logi_cke, , ),
bor3(!logi_cke, , ))
expect_equal(or3s(!logi_ckf, , w >= 0L),
bor3(!logi_ckf, , w >= 0L))
expect_equal(or3s(!logi_ckg, , j >= 1L),
bor3(!logi_ckg, , j >= 1L))
expect_equal(or3s(!logi_ckh, , t >= 9L),
bor3(!logi_ckh, , t >= 9L))
expect_equal(or3s(!logi_cki, s < 0L, ),
bor3(!logi_cki, s < 0L, ))
expect_equal(or3s(!logi_ckj, q < 1L, ),
bor3(!logi_ckj, q < 1L, ))
expect_equal(or3s(!logi_ckk, y < 9L, ),
bor3(!logi_ckk, y < 9L, ))
expect_equal(or3s(!logi_ckl, d < 0L, v >= 0L),
bor3(!logi_ckl, d < 0L, v >= 0L))
expect_equal(or3s(!logi_ckm, g < 1L, z >= 1L),
bor3(!logi_ckm, g < 1L, z >= 1L))
expect_equal(or3s(!logi_ckn, j < 9L, l >= 9L),
bor3(!logi_ckn, j < 9L, l >= 9L))
expect_equal(or3s(!logi_cko, , ),
bor3(!logi_cko, , ))
expect_equal(or3s(!logi_ckp, , ),
bor3(!logi_ckp, , ))
expect_equal(or3s(!logi_ckq, , ),
bor3(!logi_ckq, , ))
expect_equal(or3s(!logi_ckr, , logi_m),
bor3(!logi_ckr, , logi_m))
expect_equal(or3s(!logi_cks, , logi_u),
bor3(!logi_cks, , logi_u))
expect_equal(or3s(!logi_ckt, , logi_l),
bor3(!logi_ckt, , logi_l))
expect_equal(or3s(!logi_cku, j <= 0L, ),
bor3(!logi_cku, j <= 0L, ))
expect_equal(or3s(!logi_ckv, t <= 1L, ),
bor3(!logi_ckv, t <= 1L, ))
expect_equal(or3s(!logi_ckw, m <= 9L, ),
bor3(!logi_ckw, m <= 9L, ))
expect_equal(or3s(!logi_ckx, j <= 0L, logi_e),
bor3(!logi_ckx, j <= 0L, logi_e))
expect_equal(or3s(!logi_cky, m <= 1L, logi_w),
bor3(!logi_cky, m <= 1L, logi_w))
expect_equal(or3s(!logi_ckz, p <= 9L, logi_u),
bor3(!logi_ckz, p <= 9L, logi_u))
expect_equal(or3s(!logi_cla, , ),
bor3(!logi_cla, , ))
expect_equal(or3s(!logi_clb, , ),
bor3(!logi_clb, , ))
expect_equal(or3s(!logi_clc, , ),
bor3(!logi_clc, , ))
expect_equal(or3s(!logi_cld, , !logi_e),
bor3(!logi_cld, , !logi_e))
expect_equal(or3s(!logi_cle, , !logi_i),
bor3(!logi_cle, , !logi_i))
expect_equal(or3s(!logi_clf, , !logi_k),
bor3(!logi_clf, , !logi_k))
expect_equal(or3s(!logi_clg, d <= 0L, ),
bor3(!logi_clg, d <= 0L, ))
expect_equal(or3s(!logi_clh, h <= 1L, ),
bor3(!logi_clh, h <= 1L, ))
expect_equal(or3s(!logi_cli, o <= 9L, ),
bor3(!logi_cli, o <= 9L, ))
expect_equal(or3s(!logi_clj, v <= 0L, !logi_i),
bor3(!logi_clj, v <= 0L, !logi_i))
expect_equal(or3s(!logi_clk, u <= 1L, !logi_n),
bor3(!logi_clk, u <= 1L, !logi_n))
expect_equal(or3s(!logi_cll, v <= 9L, !logi_l),
bor3(!logi_cll, v <= 9L, !logi_l))
expect_equal(or3s(!logi_clm, , ),
bor3(!logi_clm, , ))
expect_equal(or3s(!logi_cln, , ),
bor3(!logi_cln, , ))
expect_equal(or3s(!logi_clo, , ),
bor3(!logi_clo, , ))
expect_equal(or3s(!logi_clp, , a != 0L),
bor3(!logi_clp, , a != 0L))
expect_equal(or3s(!logi_clq, , l != 1L),
bor3(!logi_clq, , l != 1L))
expect_equal(or3s(!logi_clr, , y != 9L),
bor3(!logi_clr, , y != 9L))
expect_equal(or3s(!logi_cls, o <= 0L, ),
bor3(!logi_cls, o <= 0L, ))
expect_equal(or3s(!logi_clt, h <= 1L, ),
bor3(!logi_clt, h <= 1L, ))
expect_equal(or3s(!logi_clu, v <= 9L, ),
bor3(!logi_clu, v <= 9L, ))
expect_equal(or3s(!logi_clv, p <= 0L, a != 0L),
bor3(!logi_clv, p <= 0L, a != 0L))
expect_equal(or3s(!logi_clw, a <= 1L, f != 1L),
bor3(!logi_clw, a <= 1L, f != 1L))
expect_equal(or3s(!logi_clx, m <= 9L, x != 9L),
bor3(!logi_clx, m <= 9L, x != 9L))
expect_equal(or3s(!logi_cly, , ),
bor3(!logi_cly, , ))
expect_equal(or3s(!logi_clz, , ),
bor3(!logi_clz, , ))
expect_equal(or3s(!logi_cma, , ),
bor3(!logi_cma, , ))
expect_equal(or3s(!logi_cmb, , w %between% c(-1L, 1L)),
bor3(!logi_cmb, , w %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cmc, , w %between% c(-1L, 1L)),
bor3(!logi_cmc, , w %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cmd, , a %between% c(-1L, 1L)),
bor3(!logi_cmd, , a %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cme, p <= 0L, ),
bor3(!logi_cme, p <= 0L, ))
expect_equal(or3s(!logi_cmf, u <= 1L, ),
bor3(!logi_cmf, u <= 1L, ))
expect_equal(or3s(!logi_cmg, n <= 9L, ),
bor3(!logi_cmg, n <= 9L, ))
expect_equal(or3s(!logi_cmh, l <= 0L, g %between% c(-1L, 1L)),
bor3(!logi_cmh, l <= 0L, g %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cmi, x <= 1L, s %between% c(-1L, 1L)),
bor3(!logi_cmi, x <= 1L, s %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cmj, c <= 9L, o %between% c(-1L, 1L)),
bor3(!logi_cmj, c <= 9L, o %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cmk, , ),
bor3(!logi_cmk, , ))
expect_equal(or3s(!logi_cml, , ),
bor3(!logi_cml, , ))
expect_equal(or3s(!logi_cmm, , ),
bor3(!logi_cmm, , ))
expect_equal(or3s(!logi_cmn, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cmn, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cmo, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cmo, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cmp, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cmp, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cmq, f <= 0L, ),
bor3(!logi_cmq, f <= 0L, ))
expect_equal(or3s(!logi_cmr, c <= 1L, ),
bor3(!logi_cmr, c <= 1L, ))
expect_equal(or3s(!logi_cms, f <= 9L, ),
bor3(!logi_cms, f <= 9L, ))
expect_equal(or3s(!logi_cmt, h <= 0L, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cmt, h <= 0L, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cmu, w <= 1L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cmu, w <= 1L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cmv, z <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cmv, z <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cmw, , ),
bor3(!logi_cmw, , ))
expect_equal(or3s(!logi_cmx, , ),
bor3(!logi_cmx, , ))
expect_equal(or3s(!logi_cmy, , ),
bor3(!logi_cmy, , ))
expect_equal(or3s(!logi_cmz, , j %in% 1:4),
bor3(!logi_cmz, , j %in% 1:4))
expect_equal(or3s(!logi_cna, , v %in% 1:4),
bor3(!logi_cna, , v %in% 1:4))
expect_equal(or3s(!logi_cnb, , t %in% 1:4),
bor3(!logi_cnb, , t %in% 1:4))
expect_equal(or3s(!logi_cnc, p <= 0L, ),
bor3(!logi_cnc, p <= 0L, ))
expect_equal(or3s(!logi_cnd, b <= 1L, ),
bor3(!logi_cnd, b <= 1L, ))
expect_equal(or3s(!logi_cne, a <= 9L, ),
bor3(!logi_cne, a <= 9L, ))
expect_equal(or3s(!logi_cnf, s <= 0L, r %in% 1:4),
bor3(!logi_cnf, s <= 0L, r %in% 1:4))
expect_equal(or3s(!logi_cng, x <= 1L, b %in% 1:4),
bor3(!logi_cng, x <= 1L, b %in% 1:4))
expect_equal(or3s(!logi_cnh, p <= 9L, f %in% 1:4),
bor3(!logi_cnh, p <= 9L, f %in% 1:4))
expect_equal(or3s(!logi_cni, , ),
bor3(!logi_cni, , ))
expect_equal(or3s(!logi_cnj, , ),
bor3(!logi_cnj, , ))
expect_equal(or3s(!logi_cnk, , ),
bor3(!logi_cnk, , ))
expect_equal(or3s(!logi_cnl, , r < 0L),
bor3(!logi_cnl, , r < 0L))
expect_equal(or3s(!logi_cnm, , f < 1L),
bor3(!logi_cnm, , f < 1L))
expect_equal(or3s(!logi_cnn, , s < 9L),
bor3(!logi_cnn, , s < 9L))
expect_equal(or3s(!logi_cno, z <= 0L, ),
bor3(!logi_cno, z <= 0L, ))
expect_equal(or3s(!logi_cnp, k <= 1L, ),
bor3(!logi_cnp, k <= 1L, ))
expect_equal(or3s(!logi_cnq, d <= 9L, ),
bor3(!logi_cnq, d <= 9L, ))
expect_equal(or3s(!logi_cnr, f <= 0L, u < 0L),
bor3(!logi_cnr, f <= 0L, u < 0L))
expect_equal(or3s(!logi_cns, w <= 1L, f < 1L),
bor3(!logi_cns, w <= 1L, f < 1L))
expect_equal(or3s(!logi_cnt, x <= 9L, i < 9L),
bor3(!logi_cnt, x <= 9L, i < 9L))
expect_equal(or3s(!logi_cnu, , ),
bor3(!logi_cnu, , ))
expect_equal(or3s(!logi_cnv, , ),
bor3(!logi_cnv, , ))
expect_equal(or3s(!logi_cnw, , ),
bor3(!logi_cnw, , ))
expect_equal(or3s(!logi_cnx, , f <= 0L),
bor3(!logi_cnx, , f <= 0L))
expect_equal(or3s(!logi_cny, , o <= 1L),
bor3(!logi_cny, , o <= 1L))
expect_equal(or3s(!logi_cnz, , g <= 9L),
bor3(!logi_cnz, , g <= 9L))
expect_equal(or3s(!logi_coa, d <= 0L, ),
bor3(!logi_coa, d <= 0L, ))
expect_equal(or3s(!logi_cob, x <= 1L, ),
bor3(!logi_cob, x <= 1L, ))
expect_equal(or3s(!logi_coc, j <= 9L, ),
bor3(!logi_coc, j <= 9L, ))
expect_equal(or3s(!logi_cod, c <= 0L, o <= 0L),
bor3(!logi_cod, c <= 0L, o <= 0L))
expect_equal(or3s(!logi_coe, w <= 1L, u <= 1L),
bor3(!logi_coe, w <= 1L, u <= 1L))
expect_equal(or3s(!logi_cof, h <= 9L, m <= 9L),
bor3(!logi_cof, h <= 9L, m <= 9L))
expect_equal(or3s(!logi_cog, , ),
bor3(!logi_cog, , ))
expect_equal(or3s(!logi_coh, , ),
bor3(!logi_coh, , ))
expect_equal(or3s(!logi_coi, , ),
bor3(!logi_coi, , ))
expect_equal(or3s(!logi_coj, , y == 0L),
bor3(!logi_coj, , y == 0L))
expect_equal(or3s(!logi_cok, , c == 1L),
bor3(!logi_cok, , c == 1L))
expect_equal(or3s(!logi_col, , o == 9L),
bor3(!logi_col, , o == 9L))
expect_equal(or3s(!logi_com, z <= 0L, ),
bor3(!logi_com, z <= 0L, ))
expect_equal(or3s(!logi_con, t <= 1L, ),
bor3(!logi_con, t <= 1L, ))
expect_equal(or3s(!logi_coo, u <= 9L, ),
bor3(!logi_coo, u <= 9L, ))
expect_equal(or3s(!logi_cop, r <= 0L, l == 0L),
bor3(!logi_cop, r <= 0L, l == 0L))
expect_equal(or3s(!logi_coq, a <= 1L, k == 1L),
bor3(!logi_coq, a <= 1L, k == 1L))
expect_equal(or3s(!logi_cor, u <= 9L, h == 9L),
bor3(!logi_cor, u <= 9L, h == 9L))
expect_equal(or3s(!logi_cos, , ),
bor3(!logi_cos, , ))
expect_equal(or3s(!logi_cot, , ),
bor3(!logi_cot, , ))
expect_equal(or3s(!logi_cou, , ),
bor3(!logi_cou, , ))
expect_equal(or3s(!logi_cov, , m > 0L),
bor3(!logi_cov, , m > 0L))
expect_equal(or3s(!logi_cow, , r > 1L),
bor3(!logi_cow, , r > 1L))
expect_equal(or3s(!logi_cox, , h > 9L),
bor3(!logi_cox, , h > 9L))
expect_equal(or3s(!logi_coy, k <= 0L, ),
bor3(!logi_coy, k <= 0L, ))
expect_equal(or3s(!logi_coz, h <= 1L, ),
bor3(!logi_coz, h <= 1L, ))
expect_equal(or3s(!logi_cpa, q <= 9L, ),
bor3(!logi_cpa, q <= 9L, ))
expect_equal(or3s(!logi_cpb, p <= 0L, g > 0L),
bor3(!logi_cpb, p <= 0L, g > 0L))
expect_equal(or3s(!logi_cpc, x <= 1L, q > 1L),
bor3(!logi_cpc, x <= 1L, q > 1L))
expect_equal(or3s(!logi_cpd, v <= 9L, d > 9L),
bor3(!logi_cpd, v <= 9L, d > 9L))
expect_equal(or3s(!logi_cpe, , ),
bor3(!logi_cpe, , ))
expect_equal(or3s(!logi_cpf, , ),
bor3(!logi_cpf, , ))
expect_equal(or3s(!logi_cpg, , ),
bor3(!logi_cpg, , ))
expect_equal(or3s(!logi_cph, , t >= 0L),
bor3(!logi_cph, , t >= 0L))
expect_equal(or3s(!logi_cpi, , q >= 1L),
bor3(!logi_cpi, , q >= 1L))
expect_equal(or3s(!logi_cpj, , j >= 9L),
bor3(!logi_cpj, , j >= 9L))
expect_equal(or3s(!logi_cpk, o <= 0L, ),
bor3(!logi_cpk, o <= 0L, ))
expect_equal(or3s(!logi_cpl, s <= 1L, ),
bor3(!logi_cpl, s <= 1L, ))
expect_equal(or3s(!logi_cpm, d <= 9L, ),
bor3(!logi_cpm, d <= 9L, ))
expect_equal(or3s(!logi_cpn, t <= 0L, g >= 0L),
bor3(!logi_cpn, t <= 0L, g >= 0L))
expect_equal(or3s(!logi_cpo, k <= 1L, x >= 1L),
bor3(!logi_cpo, k <= 1L, x >= 1L))
expect_equal(or3s(!logi_cpp, y <= 9L, c >= 9L),
bor3(!logi_cpp, y <= 9L, c >= 9L))
expect_equal(or3s(!logi_cpq, , ),
bor3(!logi_cpq, , ))
expect_equal(or3s(!logi_cpr, , ),
bor3(!logi_cpr, , ))
expect_equal(or3s(!logi_cps, , ),
bor3(!logi_cps, , ))
expect_equal(or3s(!logi_cpt, , logi_f),
bor3(!logi_cpt, , logi_f))
expect_equal(or3s(!logi_cpu, , logi_o),
bor3(!logi_cpu, , logi_o))
expect_equal(or3s(!logi_cpv, , logi_g),
bor3(!logi_cpv, , logi_g))
expect_equal(or3s(!logi_cpw, f == 0L, ),
bor3(!logi_cpw, f == 0L, ))
expect_equal(or3s(!logi_cpx, a == 1L, ),
bor3(!logi_cpx, a == 1L, ))
expect_equal(or3s(!logi_cpy, c == 9L, ),
bor3(!logi_cpy, c == 9L, ))
expect_equal(or3s(!logi_cpz, g == 0L, logi_j),
bor3(!logi_cpz, g == 0L, logi_j))
expect_equal(or3s(!logi_cqa, h == 1L, logi_j),
bor3(!logi_cqa, h == 1L, logi_j))
expect_equal(or3s(!logi_cqb, i == 9L, logi_b),
bor3(!logi_cqb, i == 9L, logi_b))
expect_equal(or3s(!logi_cqc, , ),
bor3(!logi_cqc, , ))
expect_equal(or3s(!logi_cqd, , ),
bor3(!logi_cqd, , ))
expect_equal(or3s(!logi_cqe, , ),
bor3(!logi_cqe, , ))
expect_equal(or3s(!logi_cqf, , !logi_c),
bor3(!logi_cqf, , !logi_c))
expect_equal(or3s(!logi_cqg, , !logi_g),
bor3(!logi_cqg, , !logi_g))
expect_equal(or3s(!logi_cqh, , !logi_n),
bor3(!logi_cqh, , !logi_n))
expect_equal(or3s(!logi_cqi, d == 0L, ),
bor3(!logi_cqi, d == 0L, ))
expect_equal(or3s(!logi_cqj, n == 1L, ),
bor3(!logi_cqj, n == 1L, ))
expect_equal(or3s(!logi_cqk, x == 9L, ),
bor3(!logi_cqk, x == 9L, ))
expect_equal(or3s(!logi_cql, v == 0L, !logi_v),
bor3(!logi_cql, v == 0L, !logi_v))
expect_equal(or3s(!logi_cqm, z == 1L, !logi_h),
bor3(!logi_cqm, z == 1L, !logi_h))
expect_equal(or3s(!logi_cqn, y == 9L, !logi_h),
bor3(!logi_cqn, y == 9L, !logi_h))
expect_equal(or3s(!logi_cqo, , ),
bor3(!logi_cqo, , ))
expect_equal(or3s(!logi_cqp, , ),
bor3(!logi_cqp, , ))
expect_equal(or3s(!logi_cqq, , ),
bor3(!logi_cqq, , ))
expect_equal(or3s(!logi_cqr, , i != 0L),
bor3(!logi_cqr, , i != 0L))
expect_equal(or3s(!logi_cqs, , m != 1L),
bor3(!logi_cqs, , m != 1L))
expect_equal(or3s(!logi_cqt, , q != 9L),
bor3(!logi_cqt, , q != 9L))
expect_equal(or3s(!logi_cqu, r == 0L, ),
bor3(!logi_cqu, r == 0L, ))
expect_equal(or3s(!logi_cqv, m == 1L, ),
bor3(!logi_cqv, m == 1L, ))
expect_equal(or3s(!logi_cqw, y == 9L, ),
bor3(!logi_cqw, y == 9L, ))
expect_equal(or3s(!logi_cqx, w == 0L, u != 0L),
bor3(!logi_cqx, w == 0L, u != 0L))
expect_equal(or3s(!logi_cqy, g == 1L, y != 1L),
bor3(!logi_cqy, g == 1L, y != 1L))
expect_equal(or3s(!logi_cqz, l == 9L, w != 9L),
bor3(!logi_cqz, l == 9L, w != 9L))
expect_equal(or3s(!logi_cra, , ),
bor3(!logi_cra, , ))
expect_equal(or3s(!logi_crb, , ),
bor3(!logi_crb, , ))
expect_equal(or3s(!logi_crc, , ),
bor3(!logi_crc, , ))
expect_equal(or3s(!logi_crd, , z %between% c(-1L, 1L)),
bor3(!logi_crd, , z %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cre, , j %between% c(-1L, 1L)),
bor3(!logi_cre, , j %between% c(-1L, 1L)))
expect_equal(or3s(!logi_crf, , d %between% c(-1L, 1L)),
bor3(!logi_crf, , d %between% c(-1L, 1L)))
expect_equal(or3s(!logi_crg, j == 0L, ),
bor3(!logi_crg, j == 0L, ))
expect_equal(or3s(!logi_crh, s == 1L, ),
bor3(!logi_crh, s == 1L, ))
expect_equal(or3s(!logi_cri, u == 9L, ),
bor3(!logi_cri, u == 9L, ))
expect_equal(or3s(!logi_crj, m == 0L, a %between% c(-1L, 1L)),
bor3(!logi_crj, m == 0L, a %between% c(-1L, 1L)))
expect_equal(or3s(!logi_crk, v == 1L, m %between% c(-1L, 1L)),
bor3(!logi_crk, v == 1L, m %between% c(-1L, 1L)))
expect_equal(or3s(!logi_crl, y == 9L, b %between% c(-1L, 1L)),
bor3(!logi_crl, y == 9L, b %between% c(-1L, 1L)))
expect_equal(or3s(!logi_crm, , ),
bor3(!logi_crm, , ))
expect_equal(or3s(!logi_crn, , ),
bor3(!logi_crn, , ))
expect_equal(or3s(!logi_cro, , ),
bor3(!logi_cro, , ))
expect_equal(or3s(!logi_crp, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_crp, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_crq, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_crq, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_crr, , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_crr, , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_crs, y == 0L, ),
bor3(!logi_crs, y == 0L, ))
expect_equal(or3s(!logi_crt, p == 1L, ),
bor3(!logi_crt, p == 1L, ))
expect_equal(or3s(!logi_cru, c == 9L, ),
bor3(!logi_cru, c == 9L, ))
expect_equal(or3s(!logi_crv, c == 0L, u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_crv, c == 0L, u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_crw, n == 1L, u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_crw, n == 1L, u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_crx, a == 9L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_crx, a == 9L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cry, , ),
bor3(!logi_cry, , ))
expect_equal(or3s(!logi_crz, , ),
bor3(!logi_crz, , ))
expect_equal(or3s(!logi_csa, , ),
bor3(!logi_csa, , ))
expect_equal(or3s(!logi_csb, , i %in% 1:4),
bor3(!logi_csb, , i %in% 1:4))
expect_equal(or3s(!logi_csc, , g %in% 1:4),
bor3(!logi_csc, , g %in% 1:4))
expect_equal(or3s(!logi_csd, , x %in% 1:4),
bor3(!logi_csd, , x %in% 1:4))
expect_equal(or3s(!logi_cse, e == 0L, ),
bor3(!logi_cse, e == 0L, ))
expect_equal(or3s(!logi_csf, h == 1L, ),
bor3(!logi_csf, h == 1L, ))
expect_equal(or3s(!logi_csg, p == 9L, ),
bor3(!logi_csg, p == 9L, ))
expect_equal(or3s(!logi_csh, n == 0L, j %in% 1:4),
bor3(!logi_csh, n == 0L, j %in% 1:4))
expect_equal(or3s(!logi_csi, c == 1L, d %in% 1:4),
bor3(!logi_csi, c == 1L, d %in% 1:4))
expect_equal(or3s(!logi_csj, a == 9L, j %in% 1:4),
bor3(!logi_csj, a == 9L, j %in% 1:4))
expect_equal(or3s(!logi_csk, , ),
bor3(!logi_csk, , ))
expect_equal(or3s(!logi_csl, , ),
bor3(!logi_csl, , ))
expect_equal(or3s(!logi_csm, , ),
bor3(!logi_csm, , ))
expect_equal(or3s(!logi_csn, , d < 0L),
bor3(!logi_csn, , d < 0L))
expect_equal(or3s(!logi_cso, , j < 1L),
bor3(!logi_cso, , j < 1L))
expect_equal(or3s(!logi_csp, , m < 9L),
bor3(!logi_csp, , m < 9L))
expect_equal(or3s(!logi_csq, a == 0L, ),
bor3(!logi_csq, a == 0L, ))
expect_equal(or3s(!logi_csr, z == 1L, ),
bor3(!logi_csr, z == 1L, ))
expect_equal(or3s(!logi_css, i == 9L, ),
bor3(!logi_css, i == 9L, ))
expect_equal(or3s(!logi_cst, f == 0L, q < 0L),
bor3(!logi_cst, f == 0L, q < 0L))
expect_equal(or3s(!logi_csu, j == 1L, z < 1L),
bor3(!logi_csu, j == 1L, z < 1L))
expect_equal(or3s(!logi_csv, w == 9L, o < 9L),
bor3(!logi_csv, w == 9L, o < 9L))
expect_equal(or3s(!logi_csw, , ),
bor3(!logi_csw, , ))
expect_equal(or3s(!logi_csx, , ),
bor3(!logi_csx, , ))
expect_equal(or3s(!logi_csy, , ),
bor3(!logi_csy, , ))
expect_equal(or3s(!logi_csz, , u <= 0L),
bor3(!logi_csz, , u <= 0L))
expect_equal(or3s(!logi_cta, , f <= 1L),
bor3(!logi_cta, , f <= 1L))
expect_equal(or3s(!logi_ctb, , l <= 9L),
bor3(!logi_ctb, , l <= 9L))
expect_equal(or3s(!logi_ctc, e == 0L, ),
bor3(!logi_ctc, e == 0L, ))
expect_equal(or3s(!logi_ctd, u == 1L, ),
bor3(!logi_ctd, u == 1L, ))
expect_equal(or3s(!logi_cte, p == 9L, ),
bor3(!logi_cte, p == 9L, ))
expect_equal(or3s(!logi_ctf, a == 0L, f <= 0L),
bor3(!logi_ctf, a == 0L, f <= 0L))
expect_equal(or3s(!logi_ctg, d == 1L, p <= 1L),
bor3(!logi_ctg, d == 1L, p <= 1L))
expect_equal(or3s(!logi_cth, e == 9L, e <= 9L),
bor3(!logi_cth, e == 9L, e <= 9L))
expect_equal(or3s(!logi_cti, , ),
bor3(!logi_cti, , ))
expect_equal(or3s(!logi_ctj, , ),
bor3(!logi_ctj, , ))
expect_equal(or3s(!logi_ctk, , ),
bor3(!logi_ctk, , ))
expect_equal(or3s(!logi_ctl, , v == 0L),
bor3(!logi_ctl, , v == 0L))
expect_equal(or3s(!logi_ctm, , j == 1L),
bor3(!logi_ctm, , j == 1L))
expect_equal(or3s(!logi_ctn, , y == 9L),
bor3(!logi_ctn, , y == 9L))
expect_equal(or3s(!logi_cto, y == 0L, ),
bor3(!logi_cto, y == 0L, ))
expect_equal(or3s(!logi_ctp, v == 1L, ),
bor3(!logi_ctp, v == 1L, ))
expect_equal(or3s(!logi_ctq, g == 9L, ),
bor3(!logi_ctq, g == 9L, ))
expect_equal(or3s(!logi_ctr, q == 0L, n == 0L),
bor3(!logi_ctr, q == 0L, n == 0L))
expect_equal(or3s(!logi_cts, d == 1L, m == 1L),
bor3(!logi_cts, d == 1L, m == 1L))
expect_equal(or3s(!logi_ctt, e == 9L, g == 9L),
bor3(!logi_ctt, e == 9L, g == 9L))
expect_equal(or3s(!logi_ctu, , ),
bor3(!logi_ctu, , ))
expect_equal(or3s(!logi_ctv, , ),
bor3(!logi_ctv, , ))
expect_equal(or3s(!logi_ctw, , ),
bor3(!logi_ctw, , ))
expect_equal(or3s(!logi_ctx, , o > 0L),
bor3(!logi_ctx, , o > 0L))
expect_equal(or3s(!logi_cty, , s > 1L),
bor3(!logi_cty, , s > 1L))
expect_equal(or3s(!logi_ctz, , g > 9L),
bor3(!logi_ctz, , g > 9L))
expect_equal(or3s(!logi_cua, t == 0L, ),
bor3(!logi_cua, t == 0L, ))
expect_equal(or3s(!logi_cub, f == 1L, ),
bor3(!logi_cub, f == 1L, ))
expect_equal(or3s(!logi_cuc, x == 9L, ),
bor3(!logi_cuc, x == 9L, ))
expect_equal(or3s(!logi_cud, y == 0L, k > 0L),
bor3(!logi_cud, y == 0L, k > 0L))
expect_equal(or3s(!logi_cue, e == 1L, y > 1L),
bor3(!logi_cue, e == 1L, y > 1L))
expect_equal(or3s(!logi_cuf, r == 9L, u > 9L),
bor3(!logi_cuf, r == 9L, u > 9L))
expect_equal(or3s(!logi_cug, , ),
bor3(!logi_cug, , ))
expect_equal(or3s(!logi_cuh, , ),
bor3(!logi_cuh, , ))
expect_equal(or3s(!logi_cui, , ),
bor3(!logi_cui, , ))
expect_equal(or3s(!logi_cuj, , t >= 0L),
bor3(!logi_cuj, , t >= 0L))
expect_equal(or3s(!logi_cuk, , a >= 1L),
bor3(!logi_cuk, , a >= 1L))
expect_equal(or3s(!logi_cul, , l >= 9L),
bor3(!logi_cul, , l >= 9L))
expect_equal(or3s(!logi_cum, g == 0L, ),
bor3(!logi_cum, g == 0L, ))
expect_equal(or3s(!logi_cun, t == 1L, ),
bor3(!logi_cun, t == 1L, ))
expect_equal(or3s(!logi_cuo, t == 9L, ),
bor3(!logi_cuo, t == 9L, ))
expect_equal(or3s(!logi_cup, d == 0L, v >= 0L),
bor3(!logi_cup, d == 0L, v >= 0L))
expect_equal(or3s(!logi_cuq, i == 1L, t >= 1L),
bor3(!logi_cuq, i == 1L, t >= 1L))
expect_equal(or3s(!logi_cur, m == 9L, j >= 9L),
bor3(!logi_cur, m == 9L, j >= 9L))
expect_equal(or3s(!logi_cus, , ),
bor3(!logi_cus, , ))
expect_equal(or3s(!logi_cut, , ),
bor3(!logi_cut, , ))
expect_equal(or3s(!logi_cuu, , ),
bor3(!logi_cuu, , ))
expect_equal(or3s(!logi_cuv, , logi_m),
bor3(!logi_cuv, , logi_m))
expect_equal(or3s(!logi_cuw, , logi_h),
bor3(!logi_cuw, , logi_h))
expect_equal(or3s(!logi_cux, , logi_j),
bor3(!logi_cux, , logi_j))
expect_equal(or3s(!logi_cuy, c > 0L, ),
bor3(!logi_cuy, c > 0L, ))
expect_equal(or3s(!logi_cuz, y > 1L, ),
bor3(!logi_cuz, y > 1L, ))
expect_equal(or3s(!logi_cva, x > 9L, ),
bor3(!logi_cva, x > 9L, ))
expect_equal(or3s(!logi_cvb, q > 0L, logi_k),
bor3(!logi_cvb, q > 0L, logi_k))
expect_equal(or3s(!logi_cvc, d > 1L, logi_x),
bor3(!logi_cvc, d > 1L, logi_x))
expect_equal(or3s(!logi_cvd, w > 9L, logi_a),
bor3(!logi_cvd, w > 9L, logi_a))
expect_equal(or3s(!logi_cve, , ),
bor3(!logi_cve, , ))
expect_equal(or3s(!logi_cvf, , ),
bor3(!logi_cvf, , ))
expect_equal(or3s(!logi_cvg, , ),
bor3(!logi_cvg, , ))
expect_equal(or3s(!logi_cvh, , !logi_z),
bor3(!logi_cvh, , !logi_z))
expect_equal(or3s(!logi_cvi, , !logi_t),
bor3(!logi_cvi, , !logi_t))
expect_equal(or3s(!logi_cvj, , !logi_s),
bor3(!logi_cvj, , !logi_s))
expect_equal(or3s(!logi_cvk, k > 0L, ),
bor3(!logi_cvk, k > 0L, ))
expect_equal(or3s(!logi_cvl, t > 1L, ),
bor3(!logi_cvl, t > 1L, ))
expect_equal(or3s(!logi_cvm, s > 9L, ),
bor3(!logi_cvm, s > 9L, ))
expect_equal(or3s(!logi_cvn, x > 0L, !logi_d),
bor3(!logi_cvn, x > 0L, !logi_d))
expect_equal(or3s(!logi_cvo, l > 1L, !logi_f),
bor3(!logi_cvo, l > 1L, !logi_f))
expect_equal(or3s(!logi_cvp, p > 9L, !logi_x),
bor3(!logi_cvp, p > 9L, !logi_x))
expect_equal(or3s(!logi_cvq, , ),
bor3(!logi_cvq, , ))
expect_equal(or3s(!logi_cvr, , ),
bor3(!logi_cvr, , ))
expect_equal(or3s(!logi_cvs, , ),
bor3(!logi_cvs, , ))
expect_equal(or3s(!logi_cvt, , y != 0L),
bor3(!logi_cvt, , y != 0L))
expect_equal(or3s(!logi_cvu, , s != 1L),
bor3(!logi_cvu, , s != 1L))
expect_equal(or3s(!logi_cvv, , v != 9L),
bor3(!logi_cvv, , v != 9L))
expect_equal(or3s(!logi_cvw, w > 0L, ),
bor3(!logi_cvw, w > 0L, ))
expect_equal(or3s(!logi_cvx, u > 1L, ),
bor3(!logi_cvx, u > 1L, ))
expect_equal(or3s(!logi_cvy, u > 9L, ),
bor3(!logi_cvy, u > 9L, ))
expect_equal(or3s(!logi_cvz, a > 0L, g != 0L),
bor3(!logi_cvz, a > 0L, g != 0L))
expect_equal(or3s(!logi_cwa, x > 1L, g != 1L),
bor3(!logi_cwa, x > 1L, g != 1L))
expect_equal(or3s(!logi_cwb, h > 9L, e != 9L),
bor3(!logi_cwb, h > 9L, e != 9L))
expect_equal(or3s(!logi_cwc, , ),
bor3(!logi_cwc, , ))
expect_equal(or3s(!logi_cwd, , ),
bor3(!logi_cwd, , ))
expect_equal(or3s(!logi_cwe, , ),
bor3(!logi_cwe, , ))
expect_equal(or3s(!logi_cwf, , r %between% c(-1L, 1L)),
bor3(!logi_cwf, , r %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cwg, , z %between% c(-1L, 1L)),
bor3(!logi_cwg, , z %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cwh, , o %between% c(-1L, 1L)),
bor3(!logi_cwh, , o %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cwi, q > 0L, ),
bor3(!logi_cwi, q > 0L, ))
expect_equal(or3s(!logi_cwj, l > 1L, ),
bor3(!logi_cwj, l > 1L, ))
expect_equal(or3s(!logi_cwk, x > 9L, ),
bor3(!logi_cwk, x > 9L, ))
expect_equal(or3s(!logi_cwl, e > 0L, m %between% c(-1L, 1L)),
bor3(!logi_cwl, e > 0L, m %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cwm, c > 1L, u %between% c(-1L, 1L)),
bor3(!logi_cwm, c > 1L, u %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cwn, c > 9L, y %between% c(-1L, 1L)),
bor3(!logi_cwn, c > 9L, y %between% c(-1L, 1L)))
expect_equal(or3s(!logi_cwo, , ),
bor3(!logi_cwo, , ))
expect_equal(or3s(!logi_cwp, , ),
bor3(!logi_cwp, , ))
expect_equal(or3s(!logi_cwq, , ),
bor3(!logi_cwq, , ))
expect_equal(or3s(!logi_cwr, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cwr, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cws, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cws, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cwt, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cwt, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cwu, r > 0L, ),
bor3(!logi_cwu, r > 0L, ))
expect_equal(or3s(!logi_cwv, r > 1L, ),
bor3(!logi_cwv, r > 1L, ))
expect_equal(or3s(!logi_cww, k > 9L, ),
bor3(!logi_cww, k > 9L, ))
expect_equal(or3s(!logi_cwx, b > 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cwx, b > 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cwy, a > 1L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cwy, a > 1L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cwz, q > 9L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_cwz, q > 9L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_cxa, , ),
bor3(!logi_cxa, , ))
expect_equal(or3s(!logi_cxb, , ),
bor3(!logi_cxb, , ))
expect_equal(or3s(!logi_cxc, , ),
bor3(!logi_cxc, , ))
expect_equal(or3s(!logi_cxd, , r %in% 1:4),
bor3(!logi_cxd, , r %in% 1:4))
expect_equal(or3s(!logi_cxe, , q %in% 1:4),
bor3(!logi_cxe, , q %in% 1:4))
expect_equal(or3s(!logi_cxf, , z %in% 1:4),
bor3(!logi_cxf, , z %in% 1:4))
expect_equal(or3s(!logi_cxg, z > 0L, ),
bor3(!logi_cxg, z > 0L, ))
expect_equal(or3s(!logi_cxh, z > 1L, ),
bor3(!logi_cxh, z > 1L, ))
expect_equal(or3s(!logi_cxi, g > 9L, ),
bor3(!logi_cxi, g > 9L, ))
expect_equal(or3s(!logi_cxj, n > 0L, e %in% 1:4),
bor3(!logi_cxj, n > 0L, e %in% 1:4))
expect_equal(or3s(!logi_cxk, y > 1L, a %in% 1:4),
bor3(!logi_cxk, y > 1L, a %in% 1:4))
expect_equal(or3s(!logi_cxl, x > 9L, k %in% 1:4),
bor3(!logi_cxl, x > 9L, k %in% 1:4))
expect_equal(or3s(!logi_cxm, , ),
bor3(!logi_cxm, , ))
expect_equal(or3s(!logi_cxn, , ),
bor3(!logi_cxn, , ))
expect_equal(or3s(!logi_cxo, , ),
bor3(!logi_cxo, , ))
expect_equal(or3s(!logi_cxp, , k < 0L),
bor3(!logi_cxp, , k < 0L))
expect_equal(or3s(!logi_cxq, , h < 1L),
bor3(!logi_cxq, , h < 1L))
expect_equal(or3s(!logi_cxr, , t < 9L),
bor3(!logi_cxr, , t < 9L))
expect_equal(or3s(!logi_cxs, r > 0L, ),
bor3(!logi_cxs, r > 0L, ))
expect_equal(or3s(!logi_cxt, m > 1L, ),
bor3(!logi_cxt, m > 1L, ))
expect_equal(or3s(!logi_cxu, j > 9L, ),
bor3(!logi_cxu, j > 9L, ))
expect_equal(or3s(!logi_cxv, a > 0L, b < 0L),
bor3(!logi_cxv, a > 0L, b < 0L))
expect_equal(or3s(!logi_cxw, z > 1L, e < 1L),
bor3(!logi_cxw, z > 1L, e < 1L))
expect_equal(or3s(!logi_cxx, h > 9L, a < 9L),
bor3(!logi_cxx, h > 9L, a < 9L))
expect_equal(or3s(!logi_cxy, , ),
bor3(!logi_cxy, , ))
expect_equal(or3s(!logi_cxz, , ),
bor3(!logi_cxz, , ))
expect_equal(or3s(!logi_cya, , ),
bor3(!logi_cya, , ))
expect_equal(or3s(!logi_cyb, , q <= 0L),
bor3(!logi_cyb, , q <= 0L))
expect_equal(or3s(!logi_cyc, , o <= 1L),
bor3(!logi_cyc, , o <= 1L))
expect_equal(or3s(!logi_cyd, , f <= 9L),
bor3(!logi_cyd, , f <= 9L))
expect_equal(or3s(!logi_cye, s > 0L, ),
bor3(!logi_cye, s > 0L, ))
expect_equal(or3s(!logi_cyf, v > 1L, ),
bor3(!logi_cyf, v > 1L, ))
expect_equal(or3s(!logi_cyg, r > 9L, ),
bor3(!logi_cyg, r > 9L, ))
expect_equal(or3s(!logi_cyh, b > 0L, x <= 0L),
bor3(!logi_cyh, b > 0L, x <= 0L))
expect_equal(or3s(!logi_cyi, w > 1L, m <= 1L),
bor3(!logi_cyi, w > 1L, m <= 1L))
expect_equal(or3s(!logi_cyj, c > 9L, u <= 9L),
bor3(!logi_cyj, c > 9L, u <= 9L))
expect_equal(or3s(!logi_cyk, , ),
bor3(!logi_cyk, , ))
expect_equal(or3s(!logi_cyl, , ),
bor3(!logi_cyl, , ))
expect_equal(or3s(!logi_cym, , ),
bor3(!logi_cym, , ))
expect_equal(or3s(!logi_cyn, , x == 0L),
bor3(!logi_cyn, , x == 0L))
expect_equal(or3s(!logi_cyo, , n == 1L),
bor3(!logi_cyo, , n == 1L))
expect_equal(or3s(!logi_cyp, , p == 9L),
bor3(!logi_cyp, , p == 9L))
expect_equal(or3s(!logi_cyq, r > 0L, ),
bor3(!logi_cyq, r > 0L, ))
expect_equal(or3s(!logi_cyr, v > 1L, ),
bor3(!logi_cyr, v > 1L, ))
expect_equal(or3s(!logi_cys, r > 9L, ),
bor3(!logi_cys, r > 9L, ))
expect_equal(or3s(!logi_cyt, y > 0L, c == 0L),
bor3(!logi_cyt, y > 0L, c == 0L))
expect_equal(or3s(!logi_cyu, t > 1L, r == 1L),
bor3(!logi_cyu, t > 1L, r == 1L))
expect_equal(or3s(!logi_cyv, m > 9L, v == 9L),
bor3(!logi_cyv, m > 9L, v == 9L))
expect_equal(or3s(!logi_cyw, , ),
bor3(!logi_cyw, , ))
expect_equal(or3s(!logi_cyx, , ),
bor3(!logi_cyx, , ))
expect_equal(or3s(!logi_cyy, , ),
bor3(!logi_cyy, , ))
expect_equal(or3s(!logi_cyz, , w > 0L),
bor3(!logi_cyz, , w > 0L))
expect_equal(or3s(!logi_da, , f > 1L),
bor3(!logi_da, , f > 1L))
expect_equal(or3s(!logi_db, , f > 9L),
bor3(!logi_db, , f > 9L))
expect_equal(or3s(!logi_dc, m > 0L, ),
bor3(!logi_dc, m > 0L, ))
expect_equal(or3s(!logi_dd, d > 1L, ),
bor3(!logi_dd, d > 1L, ))
expect_equal(or3s(!logi_de, o > 9L, ),
bor3(!logi_de, o > 9L, ))
expect_equal(or3s(!logi_df, f > 0L, y > 0L),
bor3(!logi_df, f > 0L, y > 0L))
expect_equal(or3s(!logi_dg, i > 1L, y > 1L),
bor3(!logi_dg, i > 1L, y > 1L))
expect_equal(or3s(!logi_dh, b > 9L, n > 9L),
bor3(!logi_dh, b > 9L, n > 9L))
expect_equal(or3s(!logi_di, , ),
bor3(!logi_di, , ))
expect_equal(or3s(!logi_dj, , ),
bor3(!logi_dj, , ))
expect_equal(or3s(!logi_dk, , ),
bor3(!logi_dk, , ))
expect_equal(or3s(!logi_dl, , z >= 0L),
bor3(!logi_dl, , z >= 0L))
expect_equal(or3s(!logi_dm, , v >= 1L),
bor3(!logi_dm, , v >= 1L))
expect_equal(or3s(!logi_dn, , y >= 9L),
bor3(!logi_dn, , y >= 9L))
expect_equal(or3s(!logi_do, f > 0L, ),
bor3(!logi_do, f > 0L, ))
expect_equal(or3s(!logi_dp, g > 1L, ),
bor3(!logi_dp, g > 1L, ))
expect_equal(or3s(!logi_dq, s > 9L, ),
bor3(!logi_dq, s > 9L, ))
expect_equal(or3s(!logi_dr, a > 0L, u >= 0L),
bor3(!logi_dr, a > 0L, u >= 0L))
expect_equal(or3s(!logi_ds, v > 1L, q >= 1L),
bor3(!logi_ds, v > 1L, q >= 1L))
expect_equal(or3s(!logi_dt, w > 9L, o >= 9L),
bor3(!logi_dt, w > 9L, o >= 9L))
expect_equal(or3s(!logi_du, , ),
bor3(!logi_du, , ))
expect_equal(or3s(!logi_dv, , ),
bor3(!logi_dv, , ))
expect_equal(or3s(!logi_dw, , ),
bor3(!logi_dw, , ))
expect_equal(or3s(!logi_dx, , logi_z),
bor3(!logi_dx, , logi_z))
expect_equal(or3s(!logi_dy, , logi_o),
bor3(!logi_dy, , logi_o))
expect_equal(or3s(!logi_dz, , logi_r),
bor3(!logi_dz, , logi_r))
expect_equal(or3s(!logi_daa, d >= 0L, ),
bor3(!logi_daa, d >= 0L, ))
expect_equal(or3s(!logi_dab, k >= 1L, ),
bor3(!logi_dab, k >= 1L, ))
expect_equal(or3s(!logi_dac, m >= 9L, ),
bor3(!logi_dac, m >= 9L, ))
expect_equal(or3s(!logi_dad, h >= 0L, logi_z),
bor3(!logi_dad, h >= 0L, logi_z))
expect_equal(or3s(!logi_dae, p >= 1L, logi_o),
bor3(!logi_dae, p >= 1L, logi_o))
expect_equal(or3s(!logi_daf, z >= 9L, logi_x),
bor3(!logi_daf, z >= 9L, logi_x))
expect_equal(or3s(!logi_dag, , ),
bor3(!logi_dag, , ))
expect_equal(or3s(!logi_dah, , ),
bor3(!logi_dah, , ))
expect_equal(or3s(!logi_dai, , ),
bor3(!logi_dai, , ))
expect_equal(or3s(!logi_daj, , !logi_l),
bor3(!logi_daj, , !logi_l))
expect_equal(or3s(!logi_dak, , !logi_p),
bor3(!logi_dak, , !logi_p))
expect_equal(or3s(!logi_dal, , !logi_q),
bor3(!logi_dal, , !logi_q))
expect_equal(or3s(!logi_dam, z >= 0L, ),
bor3(!logi_dam, z >= 0L, ))
expect_equal(or3s(!logi_dan, p >= 1L, ),
bor3(!logi_dan, p >= 1L, ))
expect_equal(or3s(!logi_dao, g >= 9L, ),
bor3(!logi_dao, g >= 9L, ))
expect_equal(or3s(!logi_dap, a >= 0L, !logi_t),
bor3(!logi_dap, a >= 0L, !logi_t))
expect_equal(or3s(!logi_daq, s >= 1L, !logi_f),
bor3(!logi_daq, s >= 1L, !logi_f))
expect_equal(or3s(!logi_dar, l >= 9L, !logi_y),
bor3(!logi_dar, l >= 9L, !logi_y))
expect_equal(or3s(!logi_das, , ),
bor3(!logi_das, , ))
expect_equal(or3s(!logi_dat, , ),
bor3(!logi_dat, , ))
expect_equal(or3s(!logi_dau, , ),
bor3(!logi_dau, , ))
expect_equal(or3s(!logi_dav, , b != 0L),
bor3(!logi_dav, , b != 0L))
expect_equal(or3s(!logi_daw, , k != 1L),
bor3(!logi_daw, , k != 1L))
expect_equal(or3s(!logi_dax, , j != 9L),
bor3(!logi_dax, , j != 9L))
expect_equal(or3s(!logi_day, w >= 0L, ),
bor3(!logi_day, w >= 0L, ))
expect_equal(or3s(!logi_daz, c >= 1L, ),
bor3(!logi_daz, c >= 1L, ))
expect_equal(or3s(!logi_dba, z >= 9L, ),
bor3(!logi_dba, z >= 9L, ))
expect_equal(or3s(!logi_dbb, q >= 0L, g != 0L),
bor3(!logi_dbb, q >= 0L, g != 0L))
expect_equal(or3s(!logi_dbc, w >= 1L, q != 1L),
bor3(!logi_dbc, w >= 1L, q != 1L))
expect_equal(or3s(!logi_dbd, a >= 9L, x != 9L),
bor3(!logi_dbd, a >= 9L, x != 9L))
expect_equal(or3s(!logi_dbe, , ),
bor3(!logi_dbe, , ))
expect_equal(or3s(!logi_dbf, , ),
bor3(!logi_dbf, , ))
expect_equal(or3s(!logi_dbg, , ),
bor3(!logi_dbg, , ))
expect_equal(or3s(!logi_dbh, , f %between% c(-1L, 1L)),
bor3(!logi_dbh, , f %between% c(-1L, 1L)))
expect_equal(or3s(!logi_dbi, , h %between% c(-1L, 1L)),
bor3(!logi_dbi, , h %between% c(-1L, 1L)))
expect_equal(or3s(!logi_dbj, , r %between% c(-1L, 1L)),
bor3(!logi_dbj, , r %between% c(-1L, 1L)))
expect_equal(or3s(!logi_dbk, x >= 0L, ),
bor3(!logi_dbk, x >= 0L, ))
expect_equal(or3s(!logi_dbl, c >= 1L, ),
bor3(!logi_dbl, c >= 1L, ))
expect_equal(or3s(!logi_dbm, n >= 9L, ),
bor3(!logi_dbm, n >= 9L, ))
expect_equal(or3s(!logi_dbn, x >= 0L, k %between% c(-1L, 1L)),
bor3(!logi_dbn, x >= 0L, k %between% c(-1L, 1L)))
expect_equal(or3s(!logi_dbo, y >= 1L, k %between% c(-1L, 1L)),
bor3(!logi_dbo, y >= 1L, k %between% c(-1L, 1L)))
expect_equal(or3s(!logi_dbp, l >= 9L, u %between% c(-1L, 1L)),
bor3(!logi_dbp, l >= 9L, u %between% c(-1L, 1L)))
expect_equal(or3s(!logi_dbq, , ),
bor3(!logi_dbq, , ))
expect_equal(or3s(!logi_dbr, , ),
bor3(!logi_dbr, , ))
expect_equal(or3s(!logi_dbs, , ),
bor3(!logi_dbs, , ))
expect_equal(or3s(!logi_dbt, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_dbt, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_dbu, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_dbu, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_dbv, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_dbv, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_dbw, g >= 0L, ),
bor3(!logi_dbw, g >= 0L, ))
expect_equal(or3s(!logi_dbx, u >= 1L, ),
bor3(!logi_dbx, u >= 1L, ))
expect_equal(or3s(!logi_dby, r >= 9L, ),
bor3(!logi_dby, r >= 9L, ))
expect_equal(or3s(!logi_dbz, c >= 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_dbz, c >= 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_dca, m >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_dca, m >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_dcb, q >= 9L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(!logi_dcb, q >= 9L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(!logi_dcc, , ),
bor3(!logi_dcc, , ))
expect_equal(or3s(!logi_dcd, , ),
bor3(!logi_dcd, , ))
expect_equal(or3s(!logi_dce, , ),
bor3(!logi_dce, , ))
expect_equal(or3s(!logi_dcf, , k %in% 1:4),
bor3(!logi_dcf, , k %in% 1:4))
expect_equal(or3s(!logi_dcg, , g %in% 1:4),
bor3(!logi_dcg, , g %in% 1:4))
expect_equal(or3s(!logi_dch, , x %in% 1:4),
bor3(!logi_dch, , x %in% 1:4))
expect_equal(or3s(!logi_dci, m >= 0L, ),
bor3(!logi_dci, m >= 0L, ))
expect_equal(or3s(!logi_dcj, e >= 1L, ),
bor3(!logi_dcj, e >= 1L, ))
expect_equal(or3s(!logi_dck, d >= 9L, ),
bor3(!logi_dck, d >= 9L, ))
expect_equal(or3s(!logi_dcl, v >= 0L, k %in% 1:4),
bor3(!logi_dcl, v >= 0L, k %in% 1:4))
expect_equal(or3s(!logi_dcm, p >= 1L, l %in% 1:4),
bor3(!logi_dcm, p >= 1L, l %in% 1:4))
expect_equal(or3s(!logi_dcn, g >= 9L, s %in% 1:4),
bor3(!logi_dcn, g >= 9L, s %in% 1:4))
expect_equal(or3s(!logi_dco, , ),
bor3(!logi_dco, , ))
expect_equal(or3s(!logi_dcp, , ),
bor3(!logi_dcp, , ))
expect_equal(or3s(!logi_dcq, , ),
bor3(!logi_dcq, , ))
expect_equal(or3s(!logi_dcr, , e < 0L),
bor3(!logi_dcr, , e < 0L))
expect_equal(or3s(!logi_dcs, , x < 1L),
bor3(!logi_dcs, , x < 1L))
expect_equal(or3s(!logi_dct, , f < 9L),
bor3(!logi_dct, , f < 9L))
expect_equal(or3s(!logi_dcu, v >= 0L, ),
bor3(!logi_dcu, v >= 0L, ))
expect_equal(or3s(!logi_dcv, x >= 1L, ),
bor3(!logi_dcv, x >= 1L, ))
expect_equal(or3s(!logi_dcw, n >= 9L, ),
bor3(!logi_dcw, n >= 9L, ))
expect_equal(or3s(!logi_dcx, w >= 0L, l < 0L),
bor3(!logi_dcx, w >= 0L, l < 0L))
expect_equal(or3s(!logi_dcy, n >= 1L, u < 1L),
bor3(!logi_dcy, n >= 1L, u < 1L))
expect_equal(or3s(!logi_dcz, h >= 9L, q < 9L),
bor3(!logi_dcz, h >= 9L, q < 9L))
expect_equal(or3s(!logi_dda, , ),
bor3(!logi_dda, , ))
expect_equal(or3s(!logi_ddb, , ),
bor3(!logi_ddb, , ))
expect_equal(or3s(!logi_ddc, , ),
bor3(!logi_ddc, , ))
expect_equal(or3s(!logi_ddd, , g <= 0L),
bor3(!logi_ddd, , g <= 0L))
expect_equal(or3s(!logi_dde, , o <= 1L),
bor3(!logi_dde, , o <= 1L))
expect_equal(or3s(!logi_ddf, , c <= 9L),
bor3(!logi_ddf, , c <= 9L))
expect_equal(or3s(!logi_ddg, i >= 0L, ),
bor3(!logi_ddg, i >= 0L, ))
expect_equal(or3s(!logi_ddh, q >= 1L, ),
bor3(!logi_ddh, q >= 1L, ))
expect_equal(or3s(!logi_ddi, o >= 9L, ),
bor3(!logi_ddi, o >= 9L, ))
expect_equal(or3s(!logi_ddj, v >= 0L, h <= 0L),
bor3(!logi_ddj, v >= 0L, h <= 0L))
expect_equal(or3s(!logi_ddk, y >= 1L, m <= 1L),
bor3(!logi_ddk, y >= 1L, m <= 1L))
expect_equal(or3s(!logi_ddl, z >= 9L, l <= 9L),
bor3(!logi_ddl, z >= 9L, l <= 9L))
expect_equal(or3s(!logi_ddm, , ),
bor3(!logi_ddm, , ))
expect_equal(or3s(!logi_ddn, , ),
bor3(!logi_ddn, , ))
expect_equal(or3s(!logi_ddo, , ),
bor3(!logi_ddo, , ))
expect_equal(or3s(!logi_ddp, , p == 0L),
bor3(!logi_ddp, , p == 0L))
expect_equal(or3s(!logi_ddq, , z == 1L),
bor3(!logi_ddq, , z == 1L))
expect_equal(or3s(!logi_ddr, , x == 9L),
bor3(!logi_ddr, , x == 9L))
expect_equal(or3s(!logi_dds, m >= 0L, ),
bor3(!logi_dds, m >= 0L, ))
expect_equal(or3s(!logi_ddt, j >= 1L, ),
bor3(!logi_ddt, j >= 1L, ))
expect_equal(or3s(!logi_ddu, s >= 9L, ),
bor3(!logi_ddu, s >= 9L, ))
expect_equal(or3s(!logi_ddv, a >= 0L, s == 0L),
bor3(!logi_ddv, a >= 0L, s == 0L))
expect_equal(or3s(!logi_ddw, t >= 1L, c == 1L),
bor3(!logi_ddw, t >= 1L, c == 1L))
expect_equal(or3s(!logi_ddx, h >= 9L, x == 9L),
bor3(!logi_ddx, h >= 9L, x == 9L))
expect_equal(or3s(!logi_ddy, , ),
bor3(!logi_ddy, , ))
expect_equal(or3s(!logi_ddz, , ),
bor3(!logi_ddz, , ))
expect_equal(or3s(!logi_dea, , ),
bor3(!logi_dea, , ))
expect_equal(or3s(!logi_deb, , d > 0L),
bor3(!logi_deb, , d > 0L))
expect_equal(or3s(!logi_dec, , u > 1L),
bor3(!logi_dec, , u > 1L))
expect_equal(or3s(!logi_ded, , a > 9L),
bor3(!logi_ded, , a > 9L))
expect_equal(or3s(!logi_dee, g >= 0L, ),
bor3(!logi_dee, g >= 0L, ))
expect_equal(or3s(!logi_def, m >= 1L, ),
bor3(!logi_def, m >= 1L, ))
expect_equal(or3s(!logi_deg, p >= 9L, ),
bor3(!logi_deg, p >= 9L, ))
expect_equal(or3s(!logi_deh, e >= 0L, i > 0L),
bor3(!logi_deh, e >= 0L, i > 0L))
expect_equal(or3s(!logi_dei, n >= 1L, i > 1L),
bor3(!logi_dei, n >= 1L, i > 1L))
expect_equal(or3s(!logi_dej, n >= 9L, j > 9L),
bor3(!logi_dej, n >= 9L, j > 9L))
expect_equal(or3s(!logi_dek, , ),
bor3(!logi_dek, , ))
expect_equal(or3s(!logi_del, , ),
bor3(!logi_del, , ))
expect_equal(or3s(!logi_dem, , ),
bor3(!logi_dem, , ))
expect_equal(or3s(!logi_den, , l >= 0L),
bor3(!logi_den, , l >= 0L))
expect_equal(or3s(!logi_deo, , v >= 1L),
bor3(!logi_deo, , v >= 1L))
expect_equal(or3s(!logi_dep, , w >= 9L),
bor3(!logi_dep, , w >= 9L))
expect_equal(or3s(!logi_deq, t >= 0L, ),
bor3(!logi_deq, t >= 0L, ))
expect_equal(or3s(!logi_der, a >= 1L, ),
bor3(!logi_der, a >= 1L, ))
expect_equal(or3s(!logi_des, n >= 9L, ),
bor3(!logi_des, n >= 9L, ))
expect_equal(or3s(!logi_det, b >= 0L, y >= 0L),
bor3(!logi_det, b >= 0L, y >= 0L))
expect_equal(or3s(!logi_deu, r >= 1L, q >= 1L),
bor3(!logi_deu, r >= 1L, q >= 1L))
expect_equal(or3s(!logi_dev, q >= 9L, z >= 9L),
bor3(!logi_dev, q >= 9L, z >= 9L))
expect_equal(or3s(dew != 0L, , ),
bor3(dew != 0L, , ))
expect_equal(or3s(dex != 1L, , ),
bor3(dex != 1L, , ))
expect_equal(or3s(dey != 9L, , ),
bor3(dey != 9L, , ))
expect_equal(or3s(dez != 0L, , logi_j),
bor3(dez != 0L, , logi_j))
expect_equal(or3s(dfa != 1L, , logi_v),
bor3(dfa != 1L, , logi_v))
expect_equal(or3s(dfb != 9L, , logi_c),
bor3(dfb != 9L, , logi_c))
expect_equal(or3s(dfc != 0L, logi_t, ),
bor3(dfc != 0L, logi_t, ))
expect_equal(or3s(dfd != 1L, logi_w, ),
bor3(dfd != 1L, logi_w, ))
expect_equal(or3s(dfe != 9L, logi_k, ),
bor3(dfe != 9L, logi_k, ))
expect_equal(or3s(dff != 0L, logi_b, logi_u),
bor3(dff != 0L, logi_b, logi_u))
expect_equal(or3s(dfg != 1L, logi_y, logi_o),
bor3(dfg != 1L, logi_y, logi_o))
expect_equal(or3s(dfh != 9L, logi_h, logi_h),
bor3(dfh != 9L, logi_h, logi_h))
expect_equal(or3s(dfi != 0L, , ),
bor3(dfi != 0L, , ))
expect_equal(or3s(dfj != 1L, , ),
bor3(dfj != 1L, , ))
expect_equal(or3s(dfk != 9L, , ),
bor3(dfk != 9L, , ))
expect_equal(or3s(dfl != 0L, , !logi_n),
bor3(dfl != 0L, , !logi_n))
expect_equal(or3s(dfm != 1L, , !logi_n),
bor3(dfm != 1L, , !logi_n))
expect_equal(or3s(dfn != 9L, , !logi_d),
bor3(dfn != 9L, , !logi_d))
expect_equal(or3s(dfo != 0L, logi_i, ),
bor3(dfo != 0L, logi_i, ))
expect_equal(or3s(dfp != 1L, logi_o, ),
bor3(dfp != 1L, logi_o, ))
expect_equal(or3s(dfq != 9L, logi_b, ),
bor3(dfq != 9L, logi_b, ))
expect_equal(or3s(dfr != 0L, logi_w, !logi_t),
bor3(dfr != 0L, logi_w, !logi_t))
expect_equal(or3s(dfs != 1L, logi_l, !logi_w),
bor3(dfs != 1L, logi_l, !logi_w))
expect_equal(or3s(dft != 9L, logi_r, !logi_y),
bor3(dft != 9L, logi_r, !logi_y))
expect_equal(or3s(dfu != 0L, , ),
bor3(dfu != 0L, , ))
expect_equal(or3s(dfv != 1L, , ),
bor3(dfv != 1L, , ))
expect_equal(or3s(dfw != 9L, , ),
bor3(dfw != 9L, , ))
expect_equal(or3s(dfx != 0L, , i != 0L),
bor3(dfx != 0L, , i != 0L))
expect_equal(or3s(dfy != 1L, , g != 1L),
bor3(dfy != 1L, , g != 1L))
expect_equal(or3s(dfz != 9L, , q != 9L),
bor3(dfz != 9L, , q != 9L))
expect_equal(or3s(dga != 0L, logi_e, ),
bor3(dga != 0L, logi_e, ))
expect_equal(or3s(dgb != 1L, logi_c, ),
bor3(dgb != 1L, logi_c, ))
expect_equal(or3s(dgc != 9L, logi_w, ),
bor3(dgc != 9L, logi_w, ))
expect_equal(or3s(dgd != 0L, logi_f, m != 0L),
bor3(dgd != 0L, logi_f, m != 0L))
expect_equal(or3s(dge != 1L, logi_p, h != 1L),
bor3(dge != 1L, logi_p, h != 1L))
expect_equal(or3s(dgf != 9L, logi_l, c != 9L),
bor3(dgf != 9L, logi_l, c != 9L))
expect_equal(or3s(dgg != 0L, , ),
bor3(dgg != 0L, , ))
expect_equal(or3s(dgh != 1L, , ),
bor3(dgh != 1L, , ))
expect_equal(or3s(dgi != 9L, , ),
bor3(dgi != 9L, , ))
expect_equal(or3s(dgj != 0L, , b %between% c(-1L, 1L)),
bor3(dgj != 0L, , b %between% c(-1L, 1L)))
expect_equal(or3s(dgk != 1L, , y %between% c(-1L, 1L)),
bor3(dgk != 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(dgl != 9L, , l %between% c(-1L, 1L)),
bor3(dgl != 9L, , l %between% c(-1L, 1L)))
expect_equal(or3s(dgm != 0L, logi_n, ),
bor3(dgm != 0L, logi_n, ))
expect_equal(or3s(dgn != 1L, logi_g, ),
bor3(dgn != 1L, logi_g, ))
expect_equal(or3s(dgo != 9L, logi_p, ),
bor3(dgo != 9L, logi_p, ))
expect_equal(or3s(dgp != 0L, logi_w, p %between% c(-1L, 1L)),
bor3(dgp != 0L, logi_w, p %between% c(-1L, 1L)))
expect_equal(or3s(dgq != 1L, logi_v, r %between% c(-1L, 1L)),
bor3(dgq != 1L, logi_v, r %between% c(-1L, 1L)))
expect_equal(or3s(dgr != 9L, logi_z, g %between% c(-1L, 1L)),
bor3(dgr != 9L, logi_z, g %between% c(-1L, 1L)))
expect_equal(or3s(dgs != 0L, , ),
bor3(dgs != 0L, , ))
expect_equal(or3s(dgt != 1L, , ),
bor3(dgt != 1L, , ))
expect_equal(or3s(dgu != 9L, , ),
bor3(dgu != 9L, , ))
expect_equal(or3s(dgv != 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dgv != 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dgw != 1L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dgw != 1L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dgx != 9L, , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dgx != 9L, , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dgy != 0L, logi_y, ),
bor3(dgy != 0L, logi_y, ))
expect_equal(or3s(dgz != 1L, logi_w, ),
bor3(dgz != 1L, logi_w, ))
expect_equal(or3s(dha != 9L, logi_s, ),
bor3(dha != 9L, logi_s, ))
expect_equal(or3s(dhb != 0L, logi_i, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dhb != 0L, logi_i, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dhc != 1L, logi_y, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dhc != 1L, logi_y, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dhd != 9L, logi_o, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dhd != 9L, logi_o, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dhe != 0L, , ),
bor3(dhe != 0L, , ))
expect_equal(or3s(dhf != 1L, , ),
bor3(dhf != 1L, , ))
expect_equal(or3s(dhg != 9L, , ),
bor3(dhg != 9L, , ))
expect_equal(or3s(dhh != 0L, , i %in% 1:4),
bor3(dhh != 0L, , i %in% 1:4))
expect_equal(or3s(dhi != 1L, , t %in% 1:4),
bor3(dhi != 1L, , t %in% 1:4))
expect_equal(or3s(dhj != 9L, , g %in% 1:4),
bor3(dhj != 9L, , g %in% 1:4))
expect_equal(or3s(dhk != 0L, logi_q, ),
bor3(dhk != 0L, logi_q, ))
expect_equal(or3s(dhl != 1L, logi_q, ),
bor3(dhl != 1L, logi_q, ))
expect_equal(or3s(dhm != 9L, logi_o, ),
bor3(dhm != 9L, logi_o, ))
expect_equal(or3s(dhn != 0L, logi_d, g %in% 1:4),
bor3(dhn != 0L, logi_d, g %in% 1:4))
expect_equal(or3s(dho != 1L, logi_a, a %in% 1:4),
bor3(dho != 1L, logi_a, a %in% 1:4))
expect_equal(or3s(dhp != 9L, logi_j, d %in% 1:4),
bor3(dhp != 9L, logi_j, d %in% 1:4))
expect_equal(or3s(dhq != 0L, , ),
bor3(dhq != 0L, , ))
expect_equal(or3s(dhr != 1L, , ),
bor3(dhr != 1L, , ))
expect_equal(or3s(dhs != 9L, , ),
bor3(dhs != 9L, , ))
expect_equal(or3s(dht != 0L, , s < 0L),
bor3(dht != 0L, , s < 0L))
expect_equal(or3s(dhu != 1L, , z < 1L),
bor3(dhu != 1L, , z < 1L))
expect_equal(or3s(dhv != 9L, , t < 9L),
bor3(dhv != 9L, , t < 9L))
expect_equal(or3s(dhw != 0L, logi_p, ),
bor3(dhw != 0L, logi_p, ))
expect_equal(or3s(dhx != 1L, logi_d, ),
bor3(dhx != 1L, logi_d, ))
expect_equal(or3s(dhy != 9L, logi_e, ),
bor3(dhy != 9L, logi_e, ))
expect_equal(or3s(dhz != 0L, logi_f, j < 0L),
bor3(dhz != 0L, logi_f, j < 0L))
expect_equal(or3s(dia != 1L, logi_a, n < 1L),
bor3(dia != 1L, logi_a, n < 1L))
expect_equal(or3s(dib != 9L, logi_h, e < 9L),
bor3(dib != 9L, logi_h, e < 9L))
expect_equal(or3s(dic != 0L, , ),
bor3(dic != 0L, , ))
expect_equal(or3s(did != 1L, , ),
bor3(did != 1L, , ))
expect_equal(or3s(die != 9L, , ),
bor3(die != 9L, , ))
expect_equal(or3s(dif != 0L, , f <= 0L),
bor3(dif != 0L, , f <= 0L))
expect_equal(or3s(dig != 1L, , z <= 1L),
bor3(dig != 1L, , z <= 1L))
expect_equal(or3s(dih != 9L, , x <= 9L),
bor3(dih != 9L, , x <= 9L))
expect_equal(or3s(dii != 0L, logi_r, ),
bor3(dii != 0L, logi_r, ))
expect_equal(or3s(dij != 1L, logi_k, ),
bor3(dij != 1L, logi_k, ))
expect_equal(or3s(dik != 9L, logi_b, ),
bor3(dik != 9L, logi_b, ))
expect_equal(or3s(dil != 0L, logi_a, g <= 0L),
bor3(dil != 0L, logi_a, g <= 0L))
expect_equal(or3s(dim != 1L, logi_l, w <= 1L),
bor3(dim != 1L, logi_l, w <= 1L))
expect_equal(or3s(din != 9L, logi_z, x <= 9L),
bor3(din != 9L, logi_z, x <= 9L))
expect_equal(or3s(dio != 0L, , ),
bor3(dio != 0L, , ))
expect_equal(or3s(dip != 1L, , ),
bor3(dip != 1L, , ))
expect_equal(or3s(diq != 9L, , ),
bor3(diq != 9L, , ))
expect_equal(or3s(dir != 0L, , j == 0L),
bor3(dir != 0L, , j == 0L))
expect_equal(or3s(dis != 1L, , k == 1L),
bor3(dis != 1L, , k == 1L))
expect_equal(or3s(dit != 9L, , i == 9L),
bor3(dit != 9L, , i == 9L))
expect_equal(or3s(diu != 0L, logi_l, ),
bor3(diu != 0L, logi_l, ))
expect_equal(or3s(div != 1L, logi_u, ),
bor3(div != 1L, logi_u, ))
expect_equal(or3s(diw != 9L, logi_q, ),
bor3(diw != 9L, logi_q, ))
expect_equal(or3s(dix != 0L, logi_m, o == 0L),
bor3(dix != 0L, logi_m, o == 0L))
expect_equal(or3s(diy != 1L, logi_u, t == 1L),
bor3(diy != 1L, logi_u, t == 1L))
expect_equal(or3s(diz != 9L, logi_v, z == 9L),
bor3(diz != 9L, logi_v, z == 9L))
expect_equal(or3s(dja != 0L, , ),
bor3(dja != 0L, , ))
expect_equal(or3s(djb != 1L, , ),
bor3(djb != 1L, , ))
expect_equal(or3s(djc != 9L, , ),
bor3(djc != 9L, , ))
expect_equal(or3s(djd != 0L, , g > 0L),
bor3(djd != 0L, , g > 0L))
expect_equal(or3s(dje != 1L, , y > 1L),
bor3(dje != 1L, , y > 1L))
expect_equal(or3s(djf != 9L, , z > 9L),
bor3(djf != 9L, , z > 9L))
expect_equal(or3s(djg != 0L, logi_c, ),
bor3(djg != 0L, logi_c, ))
expect_equal(or3s(djh != 1L, logi_w, ),
bor3(djh != 1L, logi_w, ))
expect_equal(or3s(dji != 9L, logi_e, ),
bor3(dji != 9L, logi_e, ))
expect_equal(or3s(djj != 0L, logi_u, o > 0L),
bor3(djj != 0L, logi_u, o > 0L))
expect_equal(or3s(djk != 1L, logi_z, q > 1L),
bor3(djk != 1L, logi_z, q > 1L))
expect_equal(or3s(djl != 9L, logi_v, t > 9L),
bor3(djl != 9L, logi_v, t > 9L))
expect_equal(or3s(djm != 0L, , ),
bor3(djm != 0L, , ))
expect_equal(or3s(djn != 1L, , ),
bor3(djn != 1L, , ))
expect_equal(or3s(djo != 9L, , ),
bor3(djo != 9L, , ))
expect_equal(or3s(djp != 0L, , d >= 0L),
bor3(djp != 0L, , d >= 0L))
expect_equal(or3s(djq != 1L, , g >= 1L),
bor3(djq != 1L, , g >= 1L))
expect_equal(or3s(djr != 9L, , x >= 9L),
bor3(djr != 9L, , x >= 9L))
expect_equal(or3s(djs != 0L, logi_i, ),
bor3(djs != 0L, logi_i, ))
expect_equal(or3s(djt != 1L, logi_u, ),
bor3(djt != 1L, logi_u, ))
expect_equal(or3s(dju != 9L, logi_h, ),
bor3(dju != 9L, logi_h, ))
expect_equal(or3s(djv != 0L, logi_h, d >= 0L),
bor3(djv != 0L, logi_h, d >= 0L))
expect_equal(or3s(djw != 1L, logi_f, d >= 1L),
bor3(djw != 1L, logi_f, d >= 1L))
expect_equal(or3s(djx != 9L, logi_t, s >= 9L),
bor3(djx != 9L, logi_t, s >= 9L))
expect_equal(or3s(djy != 0L, , ),
bor3(djy != 0L, , ))
expect_equal(or3s(djz != 1L, , ),
bor3(djz != 1L, , ))
expect_equal(or3s(dka != 9L, , ),
bor3(dka != 9L, , ))
expect_equal(or3s(dkb != 0L, , logi_z),
bor3(dkb != 0L, , logi_z))
expect_equal(or3s(dkc != 1L, , logi_e),
bor3(dkc != 1L, , logi_e))
expect_equal(or3s(dkd != 9L, , logi_p),
bor3(dkd != 9L, , logi_p))
expect_equal(or3s(dke != 0L, !logi_k, ),
bor3(dke != 0L, !logi_k, ))
expect_equal(or3s(dkf != 1L, !logi_o, ),
bor3(dkf != 1L, !logi_o, ))
expect_equal(or3s(dkg != 9L, !logi_b, ),
bor3(dkg != 9L, !logi_b, ))
expect_equal(or3s(dkh != 0L, !logi_z, logi_s),
bor3(dkh != 0L, !logi_z, logi_s))
expect_equal(or3s(dki != 1L, !logi_q, logi_i),
bor3(dki != 1L, !logi_q, logi_i))
expect_equal(or3s(dkj != 9L, !logi_e, logi_b),
bor3(dkj != 9L, !logi_e, logi_b))
expect_equal(or3s(dkk != 0L, , ),
bor3(dkk != 0L, , ))
expect_equal(or3s(dkl != 1L, , ),
bor3(dkl != 1L, , ))
expect_equal(or3s(dkm != 9L, , ),
bor3(dkm != 9L, , ))
expect_equal(or3s(dkn != 0L, , !logi_c),
bor3(dkn != 0L, , !logi_c))
expect_equal(or3s(dko != 1L, , !logi_j),
bor3(dko != 1L, , !logi_j))
expect_equal(or3s(dkp != 9L, , !logi_j),
bor3(dkp != 9L, , !logi_j))
expect_equal(or3s(dkq != 0L, !logi_i, ),
bor3(dkq != 0L, !logi_i, ))
expect_equal(or3s(dkr != 1L, !logi_p, ),
bor3(dkr != 1L, !logi_p, ))
expect_equal(or3s(dks != 9L, !logi_n, ),
bor3(dks != 9L, !logi_n, ))
expect_equal(or3s(dkt != 0L, !logi_g, !logi_u),
bor3(dkt != 0L, !logi_g, !logi_u))
expect_equal(or3s(dku != 1L, !logi_j, !logi_m),
bor3(dku != 1L, !logi_j, !logi_m))
expect_equal(or3s(dkv != 9L, !logi_d, !logi_n),
bor3(dkv != 9L, !logi_d, !logi_n))
expect_equal(or3s(dkw != 0L, , ),
bor3(dkw != 0L, , ))
expect_equal(or3s(dkx != 1L, , ),
bor3(dkx != 1L, , ))
expect_equal(or3s(dky != 9L, , ),
bor3(dky != 9L, , ))
expect_equal(or3s(dkz != 0L, , z != 0L),
bor3(dkz != 0L, , z != 0L))
expect_equal(or3s(dla != 1L, , k != 1L),
bor3(dla != 1L, , k != 1L))
expect_equal(or3s(dlb != 9L, , t != 9L),
bor3(dlb != 9L, , t != 9L))
expect_equal(or3s(dlc != 0L, !logi_e, ),
bor3(dlc != 0L, !logi_e, ))
expect_equal(or3s(dld != 1L, !logi_n, ),
bor3(dld != 1L, !logi_n, ))
expect_equal(or3s(dle != 9L, !logi_u, ),
bor3(dle != 9L, !logi_u, ))
expect_equal(or3s(dlf != 0L, !logi_t, o != 0L),
bor3(dlf != 0L, !logi_t, o != 0L))
expect_equal(or3s(dlg != 1L, !logi_s, i != 1L),
bor3(dlg != 1L, !logi_s, i != 1L))
expect_equal(or3s(dlh != 9L, !logi_w, a != 9L),
bor3(dlh != 9L, !logi_w, a != 9L))
expect_equal(or3s(dli != 0L, , ),
bor3(dli != 0L, , ))
expect_equal(or3s(dlj != 1L, , ),
bor3(dlj != 1L, , ))
expect_equal(or3s(dlk != 9L, , ),
bor3(dlk != 9L, , ))
expect_equal(or3s(dll != 0L, , s %between% c(-1L, 1L)),
bor3(dll != 0L, , s %between% c(-1L, 1L)))
expect_equal(or3s(dlm != 1L, , x %between% c(-1L, 1L)),
bor3(dlm != 1L, , x %between% c(-1L, 1L)))
expect_equal(or3s(dln != 9L, , x %between% c(-1L, 1L)),
bor3(dln != 9L, , x %between% c(-1L, 1L)))
expect_equal(or3s(dlo != 0L, !logi_p, ),
bor3(dlo != 0L, !logi_p, ))
expect_equal(or3s(dlp != 1L, !logi_t, ),
bor3(dlp != 1L, !logi_t, ))
expect_equal(or3s(dlq != 9L, !logi_u, ),
bor3(dlq != 9L, !logi_u, ))
expect_equal(or3s(dlr != 0L, !logi_x, b %between% c(-1L, 1L)),
bor3(dlr != 0L, !logi_x, b %between% c(-1L, 1L)))
expect_equal(or3s(dls != 1L, !logi_m, m %between% c(-1L, 1L)),
bor3(dls != 1L, !logi_m, m %between% c(-1L, 1L)))
expect_equal(or3s(dlt != 9L, !logi_m, r %between% c(-1L, 1L)),
bor3(dlt != 9L, !logi_m, r %between% c(-1L, 1L)))
expect_equal(or3s(dlu != 0L, , ),
bor3(dlu != 0L, , ))
expect_equal(or3s(dlv != 1L, , ),
bor3(dlv != 1L, , ))
expect_equal(or3s(dlw != 9L, , ),
bor3(dlw != 9L, , ))
expect_equal(or3s(dlx != 0L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dlx != 0L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dly != 1L, , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dly != 1L, , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dlz != 9L, , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dlz != 9L, , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dma != 0L, !logi_v, ),
bor3(dma != 0L, !logi_v, ))
expect_equal(or3s(dmb != 1L, !logi_k, ),
bor3(dmb != 1L, !logi_k, ))
expect_equal(or3s(dmc != 9L, !logi_h, ),
bor3(dmc != 9L, !logi_h, ))
expect_equal(or3s(dmd != 0L, !logi_w, o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dmd != 0L, !logi_w, o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dme != 1L, !logi_g, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dme != 1L, !logi_g, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dmf != 9L, !logi_q, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dmf != 9L, !logi_q, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dmg != 0L, , ),
bor3(dmg != 0L, , ))
expect_equal(or3s(dmh != 1L, , ),
bor3(dmh != 1L, , ))
expect_equal(or3s(dmi != 9L, , ),
bor3(dmi != 9L, , ))
expect_equal(or3s(dmj != 0L, , a %in% 1:4),
bor3(dmj != 0L, , a %in% 1:4))
expect_equal(or3s(dmk != 1L, , t %in% 1:4),
bor3(dmk != 1L, , t %in% 1:4))
expect_equal(or3s(dml != 9L, , p %in% 1:4),
bor3(dml != 9L, , p %in% 1:4))
expect_equal(or3s(dmm != 0L, !logi_a, ),
bor3(dmm != 0L, !logi_a, ))
expect_equal(or3s(dmn != 1L, !logi_v, ),
bor3(dmn != 1L, !logi_v, ))
expect_equal(or3s(dmo != 9L, !logi_m, ),
bor3(dmo != 9L, !logi_m, ))
expect_equal(or3s(dmp != 0L, !logi_y, o %in% 1:4),
bor3(dmp != 0L, !logi_y, o %in% 1:4))
expect_equal(or3s(dmq != 1L, !logi_x, d %in% 1:4),
bor3(dmq != 1L, !logi_x, d %in% 1:4))
expect_equal(or3s(dmr != 9L, !logi_s, o %in% 1:4),
bor3(dmr != 9L, !logi_s, o %in% 1:4))
expect_equal(or3s(dms != 0L, , ),
bor3(dms != 0L, , ))
expect_equal(or3s(dmt != 1L, , ),
bor3(dmt != 1L, , ))
expect_equal(or3s(dmu != 9L, , ),
bor3(dmu != 9L, , ))
expect_equal(or3s(dmv != 0L, , q < 0L),
bor3(dmv != 0L, , q < 0L))
expect_equal(or3s(dmw != 1L, , f < 1L),
bor3(dmw != 1L, , f < 1L))
expect_equal(or3s(dmx != 9L, , i < 9L),
bor3(dmx != 9L, , i < 9L))
expect_equal(or3s(dmy != 0L, !logi_g, ),
bor3(dmy != 0L, !logi_g, ))
expect_equal(or3s(dmz != 1L, !logi_k, ),
bor3(dmz != 1L, !logi_k, ))
expect_equal(or3s(dna != 9L, !logi_k, ),
bor3(dna != 9L, !logi_k, ))
expect_equal(or3s(dnb != 0L, !logi_p, a < 0L),
bor3(dnb != 0L, !logi_p, a < 0L))
expect_equal(or3s(dnc != 1L, !logi_z, g < 1L),
bor3(dnc != 1L, !logi_z, g < 1L))
expect_equal(or3s(dnd != 9L, !logi_d, s < 9L),
bor3(dnd != 9L, !logi_d, s < 9L))
expect_equal(or3s(dne != 0L, , ),
bor3(dne != 0L, , ))
expect_equal(or3s(dnf != 1L, , ),
bor3(dnf != 1L, , ))
expect_equal(or3s(dng != 9L, , ),
bor3(dng != 9L, , ))
expect_equal(or3s(dnh != 0L, , f <= 0L),
bor3(dnh != 0L, , f <= 0L))
expect_equal(or3s(dni != 1L, , w <= 1L),
bor3(dni != 1L, , w <= 1L))
expect_equal(or3s(dnj != 9L, , w <= 9L),
bor3(dnj != 9L, , w <= 9L))
expect_equal(or3s(dnk != 0L, !logi_c, ),
bor3(dnk != 0L, !logi_c, ))
expect_equal(or3s(dnl != 1L, !logi_h, ),
bor3(dnl != 1L, !logi_h, ))
expect_equal(or3s(dnm != 9L, !logi_k, ),
bor3(dnm != 9L, !logi_k, ))
expect_equal(or3s(dnn != 0L, !logi_e, x <= 0L),
bor3(dnn != 0L, !logi_e, x <= 0L))
expect_equal(or3s(dno != 1L, !logi_o, x <= 1L),
bor3(dno != 1L, !logi_o, x <= 1L))
expect_equal(or3s(dnp != 9L, !logi_g, s <= 9L),
bor3(dnp != 9L, !logi_g, s <= 9L))
expect_equal(or3s(dnq != 0L, , ),
bor3(dnq != 0L, , ))
expect_equal(or3s(dnr != 1L, , ),
bor3(dnr != 1L, , ))
expect_equal(or3s(dns != 9L, , ),
bor3(dns != 9L, , ))
expect_equal(or3s(dnt != 0L, , b == 0L),
bor3(dnt != 0L, , b == 0L))
expect_equal(or3s(dnu != 1L, , b == 1L),
bor3(dnu != 1L, , b == 1L))
expect_equal(or3s(dnv != 9L, , n == 9L),
bor3(dnv != 9L, , n == 9L))
expect_equal(or3s(dnw != 0L, !logi_v, ),
bor3(dnw != 0L, !logi_v, ))
expect_equal(or3s(dnx != 1L, !logi_t, ),
bor3(dnx != 1L, !logi_t, ))
expect_equal(or3s(dny != 9L, !logi_b, ),
bor3(dny != 9L, !logi_b, ))
expect_equal(or3s(dnz != 0L, !logi_x, c == 0L),
bor3(dnz != 0L, !logi_x, c == 0L))
expect_equal(or3s(doa != 1L, !logi_d, q == 1L),
bor3(doa != 1L, !logi_d, q == 1L))
expect_equal(or3s(dob != 9L, !logi_k, l == 9L),
bor3(dob != 9L, !logi_k, l == 9L))
expect_equal(or3s(doc != 0L, , ),
bor3(doc != 0L, , ))
expect_equal(or3s(dod != 1L, , ),
bor3(dod != 1L, , ))
expect_equal(or3s(doe != 9L, , ),
bor3(doe != 9L, , ))
expect_equal(or3s(dof != 0L, , w > 0L),
bor3(dof != 0L, , w > 0L))
expect_equal(or3s(dog != 1L, , a > 1L),
bor3(dog != 1L, , a > 1L))
expect_equal(or3s(doh != 9L, , p > 9L),
bor3(doh != 9L, , p > 9L))
expect_equal(or3s(doi != 0L, !logi_v, ),
bor3(doi != 0L, !logi_v, ))
expect_equal(or3s(doj != 1L, !logi_j, ),
bor3(doj != 1L, !logi_j, ))
expect_equal(or3s(dok != 9L, !logi_b, ),
bor3(dok != 9L, !logi_b, ))
expect_equal(or3s(dol != 0L, !logi_k, s > 0L),
bor3(dol != 0L, !logi_k, s > 0L))
expect_equal(or3s(dom != 1L, !logi_p, h > 1L),
bor3(dom != 1L, !logi_p, h > 1L))
expect_equal(or3s(don != 9L, !logi_n, q > 9L),
bor3(don != 9L, !logi_n, q > 9L))
expect_equal(or3s(doo != 0L, , ),
bor3(doo != 0L, , ))
expect_equal(or3s(dop != 1L, , ),
bor3(dop != 1L, , ))
expect_equal(or3s(doq != 9L, , ),
bor3(doq != 9L, , ))
expect_equal(or3s(dor != 0L, , g >= 0L),
bor3(dor != 0L, , g >= 0L))
expect_equal(or3s(dos != 1L, , l >= 1L),
bor3(dos != 1L, , l >= 1L))
expect_equal(or3s(dot != 9L, , f >= 9L),
bor3(dot != 9L, , f >= 9L))
expect_equal(or3s(dou != 0L, !logi_t, ),
bor3(dou != 0L, !logi_t, ))
expect_equal(or3s(dov != 1L, !logi_b, ),
bor3(dov != 1L, !logi_b, ))
expect_equal(or3s(dow != 9L, !logi_g, ),
bor3(dow != 9L, !logi_g, ))
expect_equal(or3s(dox != 0L, !logi_i, r >= 0L),
bor3(dox != 0L, !logi_i, r >= 0L))
expect_equal(or3s(doy != 1L, !logi_o, h >= 1L),
bor3(doy != 1L, !logi_o, h >= 1L))
expect_equal(or3s(doz != 9L, !logi_m, t >= 9L),
bor3(doz != 9L, !logi_m, t >= 9L))
expect_equal(or3s(dpa != 0L, , ),
bor3(dpa != 0L, , ))
expect_equal(or3s(dpb != 1L, , ),
bor3(dpb != 1L, , ))
expect_equal(or3s(dpc != 9L, , ),
bor3(dpc != 9L, , ))
expect_equal(or3s(dpd != 0L, , logi_p),
bor3(dpd != 0L, , logi_p))
expect_equal(or3s(dpe != 1L, , logi_f),
bor3(dpe != 1L, , logi_f))
expect_equal(or3s(dpf != 9L, , logi_k),
bor3(dpf != 9L, , logi_k))
expect_equal(or3s(dpg != 0L, i != 0L, ),
bor3(dpg != 0L, i != 0L, ))
expect_equal(or3s(dph != 1L, d != 1L, ),
bor3(dph != 1L, d != 1L, ))
expect_equal(or3s(dpi != 9L, q != 9L, ),
bor3(dpi != 9L, q != 9L, ))
expect_equal(or3s(dpj != 0L, u != 0L, logi_z),
bor3(dpj != 0L, u != 0L, logi_z))
expect_equal(or3s(dpk != 1L, k != 1L, logi_a),
bor3(dpk != 1L, k != 1L, logi_a))
expect_equal(or3s(dpl != 9L, t != 9L, logi_c),
bor3(dpl != 9L, t != 9L, logi_c))
expect_equal(or3s(dpm != 0L, , ),
bor3(dpm != 0L, , ))
expect_equal(or3s(dpn != 1L, , ),
bor3(dpn != 1L, , ))
expect_equal(or3s(dpo != 9L, , ),
bor3(dpo != 9L, , ))
expect_equal(or3s(dpp != 0L, , !logi_r),
bor3(dpp != 0L, , !logi_r))
expect_equal(or3s(dpq != 1L, , !logi_d),
bor3(dpq != 1L, , !logi_d))
expect_equal(or3s(dpr != 9L, , !logi_p),
bor3(dpr != 9L, , !logi_p))
expect_equal(or3s(dps != 0L, n != 0L, ),
bor3(dps != 0L, n != 0L, ))
expect_equal(or3s(dpt != 1L, f != 1L, ),
bor3(dpt != 1L, f != 1L, ))
expect_equal(or3s(dpu != 9L, r != 9L, ),
bor3(dpu != 9L, r != 9L, ))
expect_equal(or3s(dpv != 0L, y != 0L, !logi_v),
bor3(dpv != 0L, y != 0L, !logi_v))
expect_equal(or3s(dpw != 1L, b != 1L, !logi_w),
bor3(dpw != 1L, b != 1L, !logi_w))
expect_equal(or3s(dpx != 9L, u != 9L, !logi_r),
bor3(dpx != 9L, u != 9L, !logi_r))
expect_equal(or3s(dpy != 0L, , ),
bor3(dpy != 0L, , ))
expect_equal(or3s(dpz != 1L, , ),
bor3(dpz != 1L, , ))
expect_equal(or3s(dqa != 9L, , ),
bor3(dqa != 9L, , ))
expect_equal(or3s(dqb != 0L, , t != 0L),
bor3(dqb != 0L, , t != 0L))
expect_equal(or3s(dqc != 1L, , w != 1L),
bor3(dqc != 1L, , w != 1L))
expect_equal(or3s(dqd != 9L, , g != 9L),
bor3(dqd != 9L, , g != 9L))
expect_equal(or3s(dqe != 0L, o != 0L, ),
bor3(dqe != 0L, o != 0L, ))
expect_equal(or3s(dqf != 1L, s != 1L, ),
bor3(dqf != 1L, s != 1L, ))
expect_equal(or3s(dqg != 9L, i != 9L, ),
bor3(dqg != 9L, i != 9L, ))
expect_equal(or3s(dqh != 0L, k != 0L, u != 0L),
bor3(dqh != 0L, k != 0L, u != 0L))
expect_equal(or3s(dqi != 1L, u != 1L, m != 1L),
bor3(dqi != 1L, u != 1L, m != 1L))
expect_equal(or3s(dqj != 9L, w != 9L, q != 9L),
bor3(dqj != 9L, w != 9L, q != 9L))
expect_equal(or3s(dqk != 0L, , ),
bor3(dqk != 0L, , ))
expect_equal(or3s(dql != 1L, , ),
bor3(dql != 1L, , ))
expect_equal(or3s(dqm != 9L, , ),
bor3(dqm != 9L, , ))
expect_equal(or3s(dqn != 0L, , c %between% c(-1L, 1L)),
bor3(dqn != 0L, , c %between% c(-1L, 1L)))
expect_equal(or3s(dqo != 1L, , b %between% c(-1L, 1L)),
bor3(dqo != 1L, , b %between% c(-1L, 1L)))
expect_equal(or3s(dqp != 9L, , y %between% c(-1L, 1L)),
bor3(dqp != 9L, , y %between% c(-1L, 1L)))
expect_equal(or3s(dqq != 0L, i != 0L, ),
bor3(dqq != 0L, i != 0L, ))
expect_equal(or3s(dqr != 1L, w != 1L, ),
bor3(dqr != 1L, w != 1L, ))
expect_equal(or3s(dqs != 9L, e != 9L, ),
bor3(dqs != 9L, e != 9L, ))
expect_equal(or3s(dqt != 0L, b != 0L, r %between% c(-1L, 1L)),
bor3(dqt != 0L, b != 0L, r %between% c(-1L, 1L)))
expect_equal(or3s(dqu != 1L, s != 1L, v %between% c(-1L, 1L)),
bor3(dqu != 1L, s != 1L, v %between% c(-1L, 1L)))
expect_equal(or3s(dqv != 9L, o != 9L, h %between% c(-1L, 1L)),
bor3(dqv != 9L, o != 9L, h %between% c(-1L, 1L)))
expect_equal(or3s(dqw != 0L, , ),
bor3(dqw != 0L, , ))
expect_equal(or3s(dqx != 1L, , ),
bor3(dqx != 1L, , ))
expect_equal(or3s(dqy != 9L, , ),
bor3(dqy != 9L, , ))
expect_equal(or3s(dqz != 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dqz != 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dra != 1L, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dra != 1L, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(drb != 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(drb != 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(drc != 0L, e != 0L, ),
bor3(drc != 0L, e != 0L, ))
expect_equal(or3s(drd != 1L, e != 1L, ),
bor3(drd != 1L, e != 1L, ))
expect_equal(or3s(dre != 9L, y != 9L, ),
bor3(dre != 9L, y != 9L, ))
expect_equal(or3s(drf != 0L, l != 0L, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(drf != 0L, l != 0L, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(drg != 1L, a != 1L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(drg != 1L, a != 1L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(drh != 9L, w != 9L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(drh != 9L, w != 9L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dri != 0L, , ),
bor3(dri != 0L, , ))
expect_equal(or3s(drj != 1L, , ),
bor3(drj != 1L, , ))
expect_equal(or3s(drk != 9L, , ),
bor3(drk != 9L, , ))
expect_equal(or3s(drl != 0L, , a %in% 1:4),
bor3(drl != 0L, , a %in% 1:4))
expect_equal(or3s(drm != 1L, , n %in% 1:4),
bor3(drm != 1L, , n %in% 1:4))
expect_equal(or3s(drn != 9L, , i %in% 1:4),
bor3(drn != 9L, , i %in% 1:4))
expect_equal(or3s(dro != 0L, k != 0L, ),
bor3(dro != 0L, k != 0L, ))
expect_equal(or3s(drp != 1L, z != 1L, ),
bor3(drp != 1L, z != 1L, ))
expect_equal(or3s(drq != 9L, o != 9L, ),
bor3(drq != 9L, o != 9L, ))
expect_equal(or3s(drr != 0L, f != 0L, a %in% 1:4),
bor3(drr != 0L, f != 0L, a %in% 1:4))
expect_equal(or3s(drs != 1L, y != 1L, h %in% 1:4),
bor3(drs != 1L, y != 1L, h %in% 1:4))
expect_equal(or3s(drt != 9L, n != 9L, o %in% 1:4),
bor3(drt != 9L, n != 9L, o %in% 1:4))
expect_equal(or3s(dru != 0L, , ),
bor3(dru != 0L, , ))
expect_equal(or3s(drv != 1L, , ),
bor3(drv != 1L, , ))
expect_equal(or3s(drw != 9L, , ),
bor3(drw != 9L, , ))
expect_equal(or3s(drx != 0L, , b < 0L),
bor3(drx != 0L, , b < 0L))
expect_equal(or3s(dry != 1L, , t < 1L),
bor3(dry != 1L, , t < 1L))
expect_equal(or3s(drz != 9L, , i < 9L),
bor3(drz != 9L, , i < 9L))
expect_equal(or3s(dsa != 0L, j != 0L, ),
bor3(dsa != 0L, j != 0L, ))
expect_equal(or3s(dsb != 1L, k != 1L, ),
bor3(dsb != 1L, k != 1L, ))
expect_equal(or3s(dsc != 9L, t != 9L, ),
bor3(dsc != 9L, t != 9L, ))
expect_equal(or3s(dsd != 0L, y != 0L, q < 0L),
bor3(dsd != 0L, y != 0L, q < 0L))
expect_equal(or3s(dse != 1L, u != 1L, z < 1L),
bor3(dse != 1L, u != 1L, z < 1L))
expect_equal(or3s(dsf != 9L, i != 9L, n < 9L),
bor3(dsf != 9L, i != 9L, n < 9L))
expect_equal(or3s(dsg != 0L, , ),
bor3(dsg != 0L, , ))
expect_equal(or3s(dsh != 1L, , ),
bor3(dsh != 1L, , ))
expect_equal(or3s(dsi != 9L, , ),
bor3(dsi != 9L, , ))
expect_equal(or3s(dsj != 0L, , g <= 0L),
bor3(dsj != 0L, , g <= 0L))
expect_equal(or3s(dsk != 1L, , h <= 1L),
bor3(dsk != 1L, , h <= 1L))
expect_equal(or3s(dsl != 9L, , u <= 9L),
bor3(dsl != 9L, , u <= 9L))
expect_equal(or3s(dsm != 0L, h != 0L, ),
bor3(dsm != 0L, h != 0L, ))
expect_equal(or3s(dsn != 1L, d != 1L, ),
bor3(dsn != 1L, d != 1L, ))
expect_equal(or3s(dso != 9L, t != 9L, ),
bor3(dso != 9L, t != 9L, ))
expect_equal(or3s(dsp != 0L, s != 0L, h <= 0L),
bor3(dsp != 0L, s != 0L, h <= 0L))
expect_equal(or3s(dsq != 1L, d != 1L, i <= 1L),
bor3(dsq != 1L, d != 1L, i <= 1L))
expect_equal(or3s(dsr != 9L, s != 9L, q <= 9L),
bor3(dsr != 9L, s != 9L, q <= 9L))
expect_equal(or3s(dss != 0L, , ),
bor3(dss != 0L, , ))
expect_equal(or3s(dst != 1L, , ),
bor3(dst != 1L, , ))
expect_equal(or3s(dsu != 9L, , ),
bor3(dsu != 9L, , ))
expect_equal(or3s(dsv != 0L, , x == 0L),
bor3(dsv != 0L, , x == 0L))
expect_equal(or3s(dsw != 1L, , i == 1L),
bor3(dsw != 1L, , i == 1L))
expect_equal(or3s(dsx != 9L, , n == 9L),
bor3(dsx != 9L, , n == 9L))
expect_equal(or3s(dsy != 0L, z != 0L, ),
bor3(dsy != 0L, z != 0L, ))
expect_equal(or3s(dsz != 1L, q != 1L, ),
bor3(dsz != 1L, q != 1L, ))
expect_equal(or3s(dta != 9L, h != 9L, ),
bor3(dta != 9L, h != 9L, ))
expect_equal(or3s(dtb != 0L, s != 0L, g == 0L),
bor3(dtb != 0L, s != 0L, g == 0L))
expect_equal(or3s(dtc != 1L, f != 1L, s == 1L),
bor3(dtc != 1L, f != 1L, s == 1L))
expect_equal(or3s(dtd != 9L, m != 9L, v == 9L),
bor3(dtd != 9L, m != 9L, v == 9L))
expect_equal(or3s(dte != 0L, , ),
bor3(dte != 0L, , ))
expect_equal(or3s(dtf != 1L, , ),
bor3(dtf != 1L, , ))
expect_equal(or3s(dtg != 9L, , ),
bor3(dtg != 9L, , ))
expect_equal(or3s(dth != 0L, , s > 0L),
bor3(dth != 0L, , s > 0L))
expect_equal(or3s(dti != 1L, , u > 1L),
bor3(dti != 1L, , u > 1L))
expect_equal(or3s(dtj != 9L, , k > 9L),
bor3(dtj != 9L, , k > 9L))
expect_equal(or3s(dtk != 0L, d != 0L, ),
bor3(dtk != 0L, d != 0L, ))
expect_equal(or3s(dtl != 1L, t != 1L, ),
bor3(dtl != 1L, t != 1L, ))
expect_equal(or3s(dtm != 9L, j != 9L, ),
bor3(dtm != 9L, j != 9L, ))
expect_equal(or3s(dtn != 0L, k != 0L, c > 0L),
bor3(dtn != 0L, k != 0L, c > 0L))
expect_equal(or3s(dto != 1L, j != 1L, l > 1L),
bor3(dto != 1L, j != 1L, l > 1L))
expect_equal(or3s(dtp != 9L, y != 9L, w > 9L),
bor3(dtp != 9L, y != 9L, w > 9L))
expect_equal(or3s(dtq != 0L, , ),
bor3(dtq != 0L, , ))
expect_equal(or3s(dtr != 1L, , ),
bor3(dtr != 1L, , ))
expect_equal(or3s(dts != 9L, , ),
bor3(dts != 9L, , ))
expect_equal(or3s(dtt != 0L, , v >= 0L),
bor3(dtt != 0L, , v >= 0L))
expect_equal(or3s(dtu != 1L, , t >= 1L),
bor3(dtu != 1L, , t >= 1L))
expect_equal(or3s(dtv != 9L, , i >= 9L),
bor3(dtv != 9L, , i >= 9L))
expect_equal(or3s(dtw != 0L, n != 0L, ),
bor3(dtw != 0L, n != 0L, ))
expect_equal(or3s(dtx != 1L, n != 1L, ),
bor3(dtx != 1L, n != 1L, ))
expect_equal(or3s(dty != 9L, q != 9L, ),
bor3(dty != 9L, q != 9L, ))
expect_equal(or3s(dtz != 0L, r != 0L, a >= 0L),
bor3(dtz != 0L, r != 0L, a >= 0L))
expect_equal(or3s(dua != 1L, q != 1L, y >= 1L),
bor3(dua != 1L, q != 1L, y >= 1L))
expect_equal(or3s(dub != 9L, p != 9L, n >= 9L),
bor3(dub != 9L, p != 9L, n >= 9L))
expect_equal(or3s(duc != 0L, , ),
bor3(duc != 0L, , ))
expect_equal(or3s(dud != 1L, , ),
bor3(dud != 1L, , ))
expect_equal(or3s(due != 9L, , ),
bor3(due != 9L, , ))
expect_equal(or3s(duf != 0L, , logi_s),
bor3(duf != 0L, , logi_s))
expect_equal(or3s(dug != 1L, , logi_q),
bor3(dug != 1L, , logi_q))
expect_equal(or3s(duh != 9L, , logi_c),
bor3(duh != 9L, , logi_c))
expect_equal(or3s(dui != 0L, t %between% c(-1L, 1L), ),
bor3(dui != 0L, t %between% c(-1L, 1L), ))
expect_equal(or3s(duj != 1L, e %between% c(-1L, 1L), ),
bor3(duj != 1L, e %between% c(-1L, 1L), ))
expect_equal(or3s(duk != 9L, i %between% c(-1L, 1L), ),
bor3(duk != 9L, i %between% c(-1L, 1L), ))
expect_equal(or3s(dul != 0L, u %between% c(-1L, 1L), logi_g),
bor3(dul != 0L, u %between% c(-1L, 1L), logi_g))
expect_equal(or3s(dum != 1L, l %between% c(-1L, 1L), logi_v),
bor3(dum != 1L, l %between% c(-1L, 1L), logi_v))
expect_equal(or3s(dun != 9L, t %between% c(-1L, 1L), logi_x),
bor3(dun != 9L, t %between% c(-1L, 1L), logi_x))
expect_equal(or3s(duo != 0L, , ),
bor3(duo != 0L, , ))
expect_equal(or3s(dup != 1L, , ),
bor3(dup != 1L, , ))
expect_equal(or3s(duq != 9L, , ),
bor3(duq != 9L, , ))
expect_equal(or3s(dur != 0L, , !logi_o),
bor3(dur != 0L, , !logi_o))
expect_equal(or3s(dus != 1L, , !logi_r),
bor3(dus != 1L, , !logi_r))
expect_equal(or3s(dut != 9L, , !logi_e),
bor3(dut != 9L, , !logi_e))
expect_equal(or3s(duu != 0L, d %between% c(-1L, 1L), ),
bor3(duu != 0L, d %between% c(-1L, 1L), ))
expect_equal(or3s(duv != 1L, e %between% c(-1L, 1L), ),
bor3(duv != 1L, e %between% c(-1L, 1L), ))
expect_equal(or3s(duw != 9L, e %between% c(-1L, 1L), ),
bor3(duw != 9L, e %between% c(-1L, 1L), ))
expect_equal(or3s(dux != 0L, s %between% c(-1L, 1L), !logi_c),
bor3(dux != 0L, s %between% c(-1L, 1L), !logi_c))
expect_equal(or3s(duy != 1L, z %between% c(-1L, 1L), !logi_m),
bor3(duy != 1L, z %between% c(-1L, 1L), !logi_m))
expect_equal(or3s(duz != 9L, z %between% c(-1L, 1L), !logi_k),
bor3(duz != 9L, z %between% c(-1L, 1L), !logi_k))
expect_equal(or3s(dva != 0L, , ),
bor3(dva != 0L, , ))
expect_equal(or3s(dvb != 1L, , ),
bor3(dvb != 1L, , ))
expect_equal(or3s(dvc != 9L, , ),
bor3(dvc != 9L, , ))
expect_equal(or3s(dvd != 0L, , b != 0L),
bor3(dvd != 0L, , b != 0L))
expect_equal(or3s(dve != 1L, , e != 1L),
bor3(dve != 1L, , e != 1L))
expect_equal(or3s(dvf != 9L, , v != 9L),
bor3(dvf != 9L, , v != 9L))
expect_equal(or3s(dvg != 0L, w %between% c(-1L, 1L), ),
bor3(dvg != 0L, w %between% c(-1L, 1L), ))
expect_equal(or3s(dvh != 1L, z %between% c(-1L, 1L), ),
bor3(dvh != 1L, z %between% c(-1L, 1L), ))
expect_equal(or3s(dvi != 9L, i %between% c(-1L, 1L), ),
bor3(dvi != 9L, i %between% c(-1L, 1L), ))
expect_equal(or3s(dvj != 0L, z %between% c(-1L, 1L), e != 0L),
bor3(dvj != 0L, z %between% c(-1L, 1L), e != 0L))
expect_equal(or3s(dvk != 1L, f %between% c(-1L, 1L), b != 1L),
bor3(dvk != 1L, f %between% c(-1L, 1L), b != 1L))
expect_equal(or3s(dvl != 9L, j %between% c(-1L, 1L), o != 9L),
bor3(dvl != 9L, j %between% c(-1L, 1L), o != 9L))
expect_equal(or3s(dvm != 0L, , ),
bor3(dvm != 0L, , ))
expect_equal(or3s(dvn != 1L, , ),
bor3(dvn != 1L, , ))
expect_equal(or3s(dvo != 9L, , ),
bor3(dvo != 9L, , ))
expect_equal(or3s(dvp != 0L, , c %between% c(-1L, 1L)),
bor3(dvp != 0L, , c %between% c(-1L, 1L)))
expect_equal(or3s(dvq != 1L, , p %between% c(-1L, 1L)),
bor3(dvq != 1L, , p %between% c(-1L, 1L)))
expect_equal(or3s(dvr != 9L, , x %between% c(-1L, 1L)),
bor3(dvr != 9L, , x %between% c(-1L, 1L)))
expect_equal(or3s(dvs != 0L, t %between% c(-1L, 1L), ),
bor3(dvs != 0L, t %between% c(-1L, 1L), ))
expect_equal(or3s(dvt != 1L, d %between% c(-1L, 1L), ),
bor3(dvt != 1L, d %between% c(-1L, 1L), ))
expect_equal(or3s(dvu != 9L, w %between% c(-1L, 1L), ),
bor3(dvu != 9L, w %between% c(-1L, 1L), ))
expect_equal(or3s(dvv != 0L, s %between% c(-1L, 1L), g %between% c(-1L, 1L)),
bor3(dvv != 0L, s %between% c(-1L, 1L), g %between% c(-1L, 1L)))
expect_equal(or3s(dvw != 1L, k %between% c(-1L, 1L), q %between% c(-1L, 1L)),
bor3(dvw != 1L, k %between% c(-1L, 1L), q %between% c(-1L, 1L)))
expect_equal(or3s(dvx != 9L, w %between% c(-1L, 1L), x %between% c(-1L, 1L)),
bor3(dvx != 9L, w %between% c(-1L, 1L), x %between% c(-1L, 1L)))
expect_equal(or3s(dvy != 0L, , ),
bor3(dvy != 0L, , ))
expect_equal(or3s(dvz != 1L, , ),
bor3(dvz != 1L, , ))
expect_equal(or3s(dwa != 9L, , ),
bor3(dwa != 9L, , ))
expect_equal(or3s(dwb != 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dwb != 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dwc != 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dwc != 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dwd != 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dwd != 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dwe != 0L, x %between% c(-1L, 1L), ),
bor3(dwe != 0L, x %between% c(-1L, 1L), ))
expect_equal(or3s(dwf != 1L, d %between% c(-1L, 1L), ),
bor3(dwf != 1L, d %between% c(-1L, 1L), ))
expect_equal(or3s(dwg != 9L, v %between% c(-1L, 1L), ),
bor3(dwg != 9L, v %between% c(-1L, 1L), ))
expect_equal(or3s(dwh != 0L, w %between% c(-1L, 1L), q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dwh != 0L, w %between% c(-1L, 1L), q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dwi != 1L, n %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dwi != 1L, n %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dwj != 9L, p %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(dwj != 9L, p %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(dwk != 0L, , ),
bor3(dwk != 0L, , ))
expect_equal(or3s(dwl != 1L, , ),
bor3(dwl != 1L, , ))
expect_equal(or3s(dwm != 9L, , ),
bor3(dwm != 9L, , ))
expect_equal(or3s(dwn != 0L, , x %in% 1:4),
bor3(dwn != 0L, , x %in% 1:4))
expect_equal(or3s(dwo != 1L, , m %in% 1:4),
bor3(dwo != 1L, , m %in% 1:4))
expect_equal(or3s(dwp != 9L, , b %in% 1:4),
bor3(dwp != 9L, , b %in% 1:4))
expect_equal(or3s(dwq != 0L, o %between% c(-1L, 1L), ),
bor3(dwq != 0L, o %between% c(-1L, 1L), ))
expect_equal(or3s(dwr != 1L, r %between% c(-1L, 1L), ),
bor3(dwr != 1L, r %between% c(-1L, 1L), ))
expect_equal(or3s(dws != 9L, w %between% c(-1L, 1L), ),
bor3(dws != 9L, w %between% c(-1L, 1L), ))
expect_equal(or3s(dwt != 0L, y %between% c(-1L, 1L), e %in% 1:4),
bor3(dwt != 0L, y %between% c(-1L, 1L), e %in% 1:4))
expect_equal(or3s(dwu != 1L, x %between% c(-1L, 1L), s %in% 1:4),
bor3(dwu != 1L, x %between% c(-1L, 1L), s %in% 1:4))
expect_equal(or3s(dwv != 9L, c %between% c(-1L, 1L), z %in% 1:4),
bor3(dwv != 9L, c %between% c(-1L, 1L), z %in% 1:4))
expect_equal(or3s(dww != 0L, , ),
bor3(dww != 0L, , ))
expect_equal(or3s(dwx != 1L, , ),
bor3(dwx != 1L, , ))
expect_equal(or3s(dwy != 9L, , ),
bor3(dwy != 9L, , ))
expect_equal(or3s(dwz != 0L, , m < 0L),
bor3(dwz != 0L, , m < 0L))
expect_equal(or3s(dxa != 1L, , y < 1L),
bor3(dxa != 1L, , y < 1L))
expect_equal(or3s(dxb != 9L, , o < 9L),
bor3(dxb != 9L, , o < 9L))
expect_equal(or3s(dxc != 0L, c %between% c(-1L, 1L), ),
bor3(dxc != 0L, c %between% c(-1L, 1L), ))
expect_equal(or3s(dxd != 1L, o %between% c(-1L, 1L), ),
bor3(dxd != 1L, o %between% c(-1L, 1L), ))
expect_equal(or3s(dxe != 9L, b %between% c(-1L, 1L), ),
bor3(dxe != 9L, b %between% c(-1L, 1L), ))
expect_equal(or3s(dxf != 0L, b %between% c(-1L, 1L), d < 0L),
bor3(dxf != 0L, b %between% c(-1L, 1L), d < 0L))
expect_equal(or3s(dxg != 1L, n %between% c(-1L, 1L), g < 1L),
bor3(dxg != 1L, n %between% c(-1L, 1L), g < 1L))
expect_equal(or3s(dxh != 9L, c %between% c(-1L, 1L), p < 9L),
bor3(dxh != 9L, c %between% c(-1L, 1L), p < 9L))
expect_equal(or3s(dxi != 0L, , ),
bor3(dxi != 0L, , ))
expect_equal(or3s(dxj != 1L, , ),
bor3(dxj != 1L, , ))
expect_equal(or3s(dxk != 9L, , ),
bor3(dxk != 9L, , ))
expect_equal(or3s(dxl != 0L, , i <= 0L),
bor3(dxl != 0L, , i <= 0L))
expect_equal(or3s(dxm != 1L, , c <= 1L),
bor3(dxm != 1L, , c <= 1L))
expect_equal(or3s(dxn != 9L, , z <= 9L),
bor3(dxn != 9L, , z <= 9L))
expect_equal(or3s(dxo != 0L, j %between% c(-1L, 1L), ),
bor3(dxo != 0L, j %between% c(-1L, 1L), ))
expect_equal(or3s(dxp != 1L, f %between% c(-1L, 1L), ),
bor3(dxp != 1L, f %between% c(-1L, 1L), ))
expect_equal(or3s(dxq != 9L, n %between% c(-1L, 1L), ),
bor3(dxq != 9L, n %between% c(-1L, 1L), ))
expect_equal(or3s(dxr != 0L, q %between% c(-1L, 1L), n <= 0L),
bor3(dxr != 0L, q %between% c(-1L, 1L), n <= 0L))
expect_equal(or3s(dxs != 1L, k %between% c(-1L, 1L), u <= 1L),
bor3(dxs != 1L, k %between% c(-1L, 1L), u <= 1L))
expect_equal(or3s(dxt != 9L, c %between% c(-1L, 1L), m <= 9L),
bor3(dxt != 9L, c %between% c(-1L, 1L), m <= 9L))
expect_equal(or3s(dxu != 0L, , ),
bor3(dxu != 0L, , ))
expect_equal(or3s(dxv != 1L, , ),
bor3(dxv != 1L, , ))
expect_equal(or3s(dxw != 9L, , ),
bor3(dxw != 9L, , ))
expect_equal(or3s(dxx != 0L, , m == 0L),
bor3(dxx != 0L, , m == 0L))
expect_equal(or3s(dxy != 1L, , r == 1L),
bor3(dxy != 1L, , r == 1L))
expect_equal(or3s(dxz != 9L, , y == 9L),
bor3(dxz != 9L, , y == 9L))
expect_equal(or3s(dya != 0L, r %between% c(-1L, 1L), ),
bor3(dya != 0L, r %between% c(-1L, 1L), ))
expect_equal(or3s(dyb != 1L, p %between% c(-1L, 1L), ),
bor3(dyb != 1L, p %between% c(-1L, 1L), ))
expect_equal(or3s(dyc != 9L, j %between% c(-1L, 1L), ),
bor3(dyc != 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(dyd != 0L, d %between% c(-1L, 1L), x == 0L),
bor3(dyd != 0L, d %between% c(-1L, 1L), x == 0L))
expect_equal(or3s(dye != 1L, x %between% c(-1L, 1L), c == 1L),
bor3(dye != 1L, x %between% c(-1L, 1L), c == 1L))
expect_equal(or3s(dyf != 9L, r %between% c(-1L, 1L), d == 9L),
bor3(dyf != 9L, r %between% c(-1L, 1L), d == 9L))
expect_equal(or3s(dyg != 0L, , ),
bor3(dyg != 0L, , ))
expect_equal(or3s(dyh != 1L, , ),
bor3(dyh != 1L, , ))
expect_equal(or3s(dyi != 9L, , ),
bor3(dyi != 9L, , ))
expect_equal(or3s(dyj != 0L, , l > 0L),
bor3(dyj != 0L, , l > 0L))
expect_equal(or3s(dyk != 1L, , t > 1L),
bor3(dyk != 1L, , t > 1L))
expect_equal(or3s(dyl != 9L, , q > 9L),
bor3(dyl != 9L, , q > 9L))
expect_equal(or3s(dym != 0L, e %between% c(-1L, 1L), ),
bor3(dym != 0L, e %between% c(-1L, 1L), ))
expect_equal(or3s(dyn != 1L, s %between% c(-1L, 1L), ),
bor3(dyn != 1L, s %between% c(-1L, 1L), ))
expect_equal(or3s(dyo != 9L, a %between% c(-1L, 1L), ),
bor3(dyo != 9L, a %between% c(-1L, 1L), ))
expect_equal(or3s(dyp != 0L, v %between% c(-1L, 1L), f > 0L),
bor3(dyp != 0L, v %between% c(-1L, 1L), f > 0L))
expect_equal(or3s(dyq != 1L, h %between% c(-1L, 1L), q > 1L),
bor3(dyq != 1L, h %between% c(-1L, 1L), q > 1L))
expect_equal(or3s(dyr != 9L, o %between% c(-1L, 1L), i > 9L),
bor3(dyr != 9L, o %between% c(-1L, 1L), i > 9L))
expect_equal(or3s(dys != 0L, , ),
bor3(dys != 0L, , ))
expect_equal(or3s(dyt != 1L, , ),
bor3(dyt != 1L, , ))
expect_equal(or3s(dyu != 9L, , ),
bor3(dyu != 9L, , ))
expect_equal(or3s(dyv != 0L, , x >= 0L),
bor3(dyv != 0L, , x >= 0L))
expect_equal(or3s(dyw != 1L, , x >= 1L),
bor3(dyw != 1L, , x >= 1L))
expect_equal(or3s(dyx != 9L, , u >= 9L),
bor3(dyx != 9L, , u >= 9L))
expect_equal(or3s(dyy != 0L, x %between% c(-1L, 1L), ),
bor3(dyy != 0L, x %between% c(-1L, 1L), ))
expect_equal(or3s(dyz != 1L, k %between% c(-1L, 1L), ),
bor3(dyz != 1L, k %between% c(-1L, 1L), ))
expect_equal(or3s(ea != 9L, o %between% c(-1L, 1L), ),
bor3(ea != 9L, o %between% c(-1L, 1L), ))
expect_equal(or3s(eb != 0L, l %between% c(-1L, 1L), b >= 0L),
bor3(eb != 0L, l %between% c(-1L, 1L), b >= 0L))
expect_equal(or3s(ec != 1L, w %between% c(-1L, 1L), f >= 1L),
bor3(ec != 1L, w %between% c(-1L, 1L), f >= 1L))
expect_equal(or3s(ed != 9L, q %between% c(-1L, 1L), v >= 9L),
bor3(ed != 9L, q %between% c(-1L, 1L), v >= 9L))
expect_equal(or3s(ee != 0L, , ),
bor3(ee != 0L, , ))
expect_equal(or3s(ef != 1L, , ),
bor3(ef != 1L, , ))
expect_equal(or3s(eg != 9L, , ),
bor3(eg != 9L, , ))
expect_equal(or3s(eh != 0L, , logi_z),
bor3(eh != 0L, , logi_z))
expect_equal(or3s(ei != 1L, , logi_v),
bor3(ei != 1L, , logi_v))
expect_equal(or3s(ej != 9L, , logi_m),
bor3(ej != 9L, , logi_m))
expect_equal(or3s(ek != 0L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ek != 0L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(el != 1L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(el != 1L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(em != 9L, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(em != 9L, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(en != 0L, p %in% c(4L, -3L, 2L, 7L, 8L), logi_l),
bor3(en != 0L, p %in% c(4L, -3L, 2L, 7L, 8L), logi_l))
expect_equal(or3s(eo != 1L, q %in% c(4L, -3L, 2L, 7L, 8L), logi_m),
bor3(eo != 1L, q %in% c(4L, -3L, 2L, 7L, 8L), logi_m))
expect_equal(or3s(ep != 9L, m %in% c(4L, -3L, 2L, 7L, 8L), logi_f),
bor3(ep != 9L, m %in% c(4L, -3L, 2L, 7L, 8L), logi_f))
expect_equal(or3s(eq != 0L, , ),
bor3(eq != 0L, , ))
expect_equal(or3s(er != 1L, , ),
bor3(er != 1L, , ))
expect_equal(or3s(es != 9L, , ),
bor3(es != 9L, , ))
expect_equal(or3s(et != 0L, , logi_t),
bor3(et != 0L, , logi_t))
expect_equal(or3s(eu != 1L, , logi_c),
bor3(eu != 1L, , logi_c))
expect_equal(or3s(ev != 9L, , logi_l),
bor3(ev != 9L, , logi_l))
expect_equal(or3s(ew != 0L, e %in% 1:4, ),
bor3(ew != 0L, e %in% 1:4, ))
expect_equal(or3s(ex != 1L, h %in% 1:4, ),
bor3(ex != 1L, h %in% 1:4, ))
expect_equal(or3s(ey != 9L, l %in% 1:4, ),
bor3(ey != 9L, l %in% 1:4, ))
expect_equal(or3s(ez != 0L, m %in% 1:4, logi_f),
bor3(ez != 0L, m %in% 1:4, logi_f))
expect_equal(or3s(eaa != 1L, g %in% 1:4, logi_q),
bor3(eaa != 1L, g %in% 1:4, logi_q))
expect_equal(or3s(eab != 9L, l %in% 1:4, logi_u),
bor3(eab != 9L, l %in% 1:4, logi_u))
expect_equal(or3s(eac != 0L, , ),
bor3(eac != 0L, , ))
expect_equal(or3s(ead != 1L, , ),
bor3(ead != 1L, , ))
expect_equal(or3s(eae != 9L, , ),
bor3(eae != 9L, , ))
expect_equal(or3s(eaf != 0L, , !logi_y),
bor3(eaf != 0L, , !logi_y))
expect_equal(or3s(eag != 1L, , !logi_q),
bor3(eag != 1L, , !logi_q))
expect_equal(or3s(eah != 9L, , !logi_a),
bor3(eah != 9L, , !logi_a))
expect_equal(or3s(eai != 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eai != 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eaj != 1L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eaj != 1L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eak != 9L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eak != 9L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eal != 0L, j %in% c(4L, -3L, 2L, 7L, 8L), !logi_u),
bor3(eal != 0L, j %in% c(4L, -3L, 2L, 7L, 8L), !logi_u))
expect_equal(or3s(eam != 1L, t %in% c(4L, -3L, 2L, 7L, 8L), !logi_m),
bor3(eam != 1L, t %in% c(4L, -3L, 2L, 7L, 8L), !logi_m))
expect_equal(or3s(ean != 9L, t %in% c(4L, -3L, 2L, 7L, 8L), !logi_r),
bor3(ean != 9L, t %in% c(4L, -3L, 2L, 7L, 8L), !logi_r))
expect_equal(or3s(eao != 0L, , ),
bor3(eao != 0L, , ))
expect_equal(or3s(eap != 1L, , ),
bor3(eap != 1L, , ))
expect_equal(or3s(eaq != 9L, , ),
bor3(eaq != 9L, , ))
expect_equal(or3s(ear != 0L, , !logi_e),
bor3(ear != 0L, , !logi_e))
expect_equal(or3s(eas != 1L, , !logi_a),
bor3(eas != 1L, , !logi_a))
expect_equal(or3s(eat != 9L, , !logi_l),
bor3(eat != 9L, , !logi_l))
expect_equal(or3s(eau != 0L, m %in% 1:4, ),
bor3(eau != 0L, m %in% 1:4, ))
expect_equal(or3s(eav != 1L, w %in% 1:4, ),
bor3(eav != 1L, w %in% 1:4, ))
expect_equal(or3s(eaw != 9L, k %in% 1:4, ),
bor3(eaw != 9L, k %in% 1:4, ))
expect_equal(or3s(eax != 0L, n %in% 1:4, !logi_n),
bor3(eax != 0L, n %in% 1:4, !logi_n))
expect_equal(or3s(eay != 1L, j %in% 1:4, !logi_w),
bor3(eay != 1L, j %in% 1:4, !logi_w))
expect_equal(or3s(eaz != 9L, b %in% 1:4, !logi_l),
bor3(eaz != 9L, b %in% 1:4, !logi_l))
expect_equal(or3s(eba != 0L, , ),
bor3(eba != 0L, , ))
expect_equal(or3s(ebb != 1L, , ),
bor3(ebb != 1L, , ))
expect_equal(or3s(ebc != 9L, , ),
bor3(ebc != 9L, , ))
expect_equal(or3s(ebd != 0L, , b != 0L),
bor3(ebd != 0L, , b != 0L))
expect_equal(or3s(ebe != 1L, , o != 1L),
bor3(ebe != 1L, , o != 1L))
expect_equal(or3s(ebf != 9L, , s != 9L),
bor3(ebf != 9L, , s != 9L))
expect_equal(or3s(ebg != 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ebg != 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ebh != 1L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ebh != 1L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ebi != 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ebi != 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ebj != 0L, x %in% c(4L, -3L, 2L, 7L, 8L), t != 0L),
bor3(ebj != 0L, x %in% c(4L, -3L, 2L, 7L, 8L), t != 0L))
expect_equal(or3s(ebk != 1L, j %in% c(4L, -3L, 2L, 7L, 8L), a != 1L),
bor3(ebk != 1L, j %in% c(4L, -3L, 2L, 7L, 8L), a != 1L))
expect_equal(or3s(ebl != 9L, r %in% c(4L, -3L, 2L, 7L, 8L), g != 9L),
bor3(ebl != 9L, r %in% c(4L, -3L, 2L, 7L, 8L), g != 9L))
expect_equal(or3s(ebm != 0L, , ),
bor3(ebm != 0L, , ))
expect_equal(or3s(ebn != 1L, , ),
bor3(ebn != 1L, , ))
expect_equal(or3s(ebo != 9L, , ),
bor3(ebo != 9L, , ))
expect_equal(or3s(ebp != 0L, , k != 0L),
bor3(ebp != 0L, , k != 0L))
expect_equal(or3s(ebq != 1L, , g != 1L),
bor3(ebq != 1L, , g != 1L))
expect_equal(or3s(ebr != 9L, , o != 9L),
bor3(ebr != 9L, , o != 9L))
expect_equal(or3s(ebs != 0L, z %in% 1:4, ),
bor3(ebs != 0L, z %in% 1:4, ))
expect_equal(or3s(ebt != 1L, x %in% 1:4, ),
bor3(ebt != 1L, x %in% 1:4, ))
expect_equal(or3s(ebu != 9L, i %in% 1:4, ),
bor3(ebu != 9L, i %in% 1:4, ))
expect_equal(or3s(ebv != 0L, g %in% 1:4, a != 0L),
bor3(ebv != 0L, g %in% 1:4, a != 0L))
expect_equal(or3s(ebw != 1L, d %in% 1:4, o != 1L),
bor3(ebw != 1L, d %in% 1:4, o != 1L))
expect_equal(or3s(ebx != 9L, c %in% 1:4, r != 9L),
bor3(ebx != 9L, c %in% 1:4, r != 9L))
expect_equal(or3s(eby != 0L, , ),
bor3(eby != 0L, , ))
expect_equal(or3s(ebz != 1L, , ),
bor3(ebz != 1L, , ))
expect_equal(or3s(eca != 9L, , ),
bor3(eca != 9L, , ))
expect_equal(or3s(ecb != 0L, , k %between% c(-1L, 1L)),
bor3(ecb != 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(ecc != 1L, , r %between% c(-1L, 1L)),
bor3(ecc != 1L, , r %between% c(-1L, 1L)))
expect_equal(or3s(ecd != 9L, , a %between% c(-1L, 1L)),
bor3(ecd != 9L, , a %between% c(-1L, 1L)))
expect_equal(or3s(ece != 0L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ece != 0L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ecf != 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ecf != 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ecg != 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ecg != 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ech != 0L, d %in% c(4L, -3L, 2L, 7L, 8L), s %between% c(-1L, 1L)),
bor3(ech != 0L, d %in% c(4L, -3L, 2L, 7L, 8L), s %between% c(-1L, 1L)))
expect_equal(or3s(eci != 1L, y %in% c(4L, -3L, 2L, 7L, 8L), r %between% c(-1L, 1L)),
bor3(eci != 1L, y %in% c(4L, -3L, 2L, 7L, 8L), r %between% c(-1L, 1L)))
expect_equal(or3s(ecj != 9L, a %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L)),
bor3(ecj != 9L, a %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L)))
expect_equal(or3s(eck != 0L, , ),
bor3(eck != 0L, , ))
expect_equal(or3s(ecl != 1L, , ),
bor3(ecl != 1L, , ))
expect_equal(or3s(ecm != 9L, , ),
bor3(ecm != 9L, , ))
expect_equal(or3s(ecn != 0L, , p %between% c(-1L, 1L)),
bor3(ecn != 0L, , p %between% c(-1L, 1L)))
expect_equal(or3s(eco != 1L, , p %between% c(-1L, 1L)),
bor3(eco != 1L, , p %between% c(-1L, 1L)))
expect_equal(or3s(ecp != 9L, , k %between% c(-1L, 1L)),
bor3(ecp != 9L, , k %between% c(-1L, 1L)))
expect_equal(or3s(ecq != 0L, k %in% 1:4, ),
bor3(ecq != 0L, k %in% 1:4, ))
expect_equal(or3s(ecr != 1L, s %in% 1:4, ),
bor3(ecr != 1L, s %in% 1:4, ))
expect_equal(or3s(ecs != 9L, q %in% 1:4, ),
bor3(ecs != 9L, q %in% 1:4, ))
expect_equal(or3s(ect != 0L, g %in% 1:4, w %between% c(-1L, 1L)),
bor3(ect != 0L, g %in% 1:4, w %between% c(-1L, 1L)))
expect_equal(or3s(ecu != 1L, k %in% 1:4, c %between% c(-1L, 1L)),
bor3(ecu != 1L, k %in% 1:4, c %between% c(-1L, 1L)))
expect_equal(or3s(ecv != 9L, i %in% 1:4, a %between% c(-1L, 1L)),
bor3(ecv != 9L, i %in% 1:4, a %between% c(-1L, 1L)))
expect_equal(or3s(ecw != 0L, , ),
bor3(ecw != 0L, , ))
expect_equal(or3s(ecx != 1L, , ),
bor3(ecx != 1L, , ))
expect_equal(or3s(ecy != 9L, , ),
bor3(ecy != 9L, , ))
expect_equal(or3s(ecz != 0L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ecz != 0L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(eda != 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(eda != 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(edb != 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(edb != 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(edc != 0L, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(edc != 0L, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(edd != 1L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(edd != 1L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ede != 9L, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ede != 9L, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(edf != 0L, k %in% c(4L, -3L, 2L, 7L, 8L), p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(edf != 0L, k %in% c(4L, -3L, 2L, 7L, 8L), p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(edg != 1L, r %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(edg != 1L, r %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(edh != 9L, b %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(edh != 9L, b %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(edi != 0L, , ),
bor3(edi != 0L, , ))
expect_equal(or3s(edj != 1L, , ),
bor3(edj != 1L, , ))
expect_equal(or3s(edk != 9L, , ),
bor3(edk != 9L, , ))
expect_equal(or3s(edl != 0L, , u %in% 1:4),
bor3(edl != 0L, , u %in% 1:4))
expect_equal(or3s(edm != 1L, , v %in% 1:4),
bor3(edm != 1L, , v %in% 1:4))
expect_equal(or3s(edn != 9L, , h %in% 1:4),
bor3(edn != 9L, , h %in% 1:4))
expect_equal(or3s(edo != 0L, f %in% 1:4, ),
bor3(edo != 0L, f %in% 1:4, ))
expect_equal(or3s(edp != 1L, h %in% 1:4, ),
bor3(edp != 1L, h %in% 1:4, ))
expect_equal(or3s(edq != 9L, h %in% 1:4, ),
bor3(edq != 9L, h %in% 1:4, ))
expect_equal(or3s(edr != 0L, y %in% 1:4, i %in% 1:4),
bor3(edr != 0L, y %in% 1:4, i %in% 1:4))
expect_equal(or3s(eds != 1L, d %in% 1:4, s %in% 1:4),
bor3(eds != 1L, d %in% 1:4, s %in% 1:4))
expect_equal(or3s(edt != 9L, q %in% 1:4, i %in% 1:4),
bor3(edt != 9L, q %in% 1:4, i %in% 1:4))
expect_equal(or3s(edu != 0L, , ),
bor3(edu != 0L, , ))
expect_equal(or3s(edv != 1L, , ),
bor3(edv != 1L, , ))
expect_equal(or3s(edw != 9L, , ),
bor3(edw != 9L, , ))
expect_equal(or3s(edx != 0L, , v < 0L),
bor3(edx != 0L, , v < 0L))
expect_equal(or3s(edy != 1L, , w < 1L),
bor3(edy != 1L, , w < 1L))
expect_equal(or3s(edz != 9L, , q < 9L),
bor3(edz != 9L, , q < 9L))
expect_equal(or3s(eea != 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eea != 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eeb != 1L, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eeb != 1L, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eec != 9L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eec != 9L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eed != 0L, c %in% c(4L, -3L, 2L, 7L, 8L), d < 0L),
bor3(eed != 0L, c %in% c(4L, -3L, 2L, 7L, 8L), d < 0L))
expect_equal(or3s(eee != 1L, p %in% c(4L, -3L, 2L, 7L, 8L), y < 1L),
bor3(eee != 1L, p %in% c(4L, -3L, 2L, 7L, 8L), y < 1L))
expect_equal(or3s(eef != 9L, n %in% c(4L, -3L, 2L, 7L, 8L), a < 9L),
bor3(eef != 9L, n %in% c(4L, -3L, 2L, 7L, 8L), a < 9L))
expect_equal(or3s(eeg != 0L, , ),
bor3(eeg != 0L, , ))
expect_equal(or3s(eeh != 1L, , ),
bor3(eeh != 1L, , ))
expect_equal(or3s(eei != 9L, , ),
bor3(eei != 9L, , ))
expect_equal(or3s(eej != 0L, , w < 0L),
bor3(eej != 0L, , w < 0L))
expect_equal(or3s(eek != 1L, , c < 1L),
bor3(eek != 1L, , c < 1L))
expect_equal(or3s(eel != 9L, , k < 9L),
bor3(eel != 9L, , k < 9L))
expect_equal(or3s(eem != 0L, w %in% 1:4, ),
bor3(eem != 0L, w %in% 1:4, ))
expect_equal(or3s(een != 1L, g %in% 1:4, ),
bor3(een != 1L, g %in% 1:4, ))
expect_equal(or3s(eeo != 9L, v %in% 1:4, ),
bor3(eeo != 9L, v %in% 1:4, ))
expect_equal(or3s(eep != 0L, c %in% 1:4, o < 0L),
bor3(eep != 0L, c %in% 1:4, o < 0L))
expect_equal(or3s(eeq != 1L, u %in% 1:4, m < 1L),
bor3(eeq != 1L, u %in% 1:4, m < 1L))
expect_equal(or3s(eer != 9L, l %in% 1:4, p < 9L),
bor3(eer != 9L, l %in% 1:4, p < 9L))
expect_equal(or3s(ees != 0L, , ),
bor3(ees != 0L, , ))
expect_equal(or3s(eet != 1L, , ),
bor3(eet != 1L, , ))
expect_equal(or3s(eeu != 9L, , ),
bor3(eeu != 9L, , ))
expect_equal(or3s(eev != 0L, , w <= 0L),
bor3(eev != 0L, , w <= 0L))
expect_equal(or3s(eew != 1L, , w <= 1L),
bor3(eew != 1L, , w <= 1L))
expect_equal(or3s(eex != 9L, , m <= 9L),
bor3(eex != 9L, , m <= 9L))
expect_equal(or3s(eey != 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eey != 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eez != 1L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eez != 1L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(efa != 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(efa != 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(efb != 0L, r %in% c(4L, -3L, 2L, 7L, 8L), m <= 0L),
bor3(efb != 0L, r %in% c(4L, -3L, 2L, 7L, 8L), m <= 0L))
expect_equal(or3s(efc != 1L, n %in% c(4L, -3L, 2L, 7L, 8L), a <= 1L),
bor3(efc != 1L, n %in% c(4L, -3L, 2L, 7L, 8L), a <= 1L))
expect_equal(or3s(efd != 9L, b %in% c(4L, -3L, 2L, 7L, 8L), k <= 9L),
bor3(efd != 9L, b %in% c(4L, -3L, 2L, 7L, 8L), k <= 9L))
expect_equal(or3s(efe != 0L, , ),
bor3(efe != 0L, , ))
expect_equal(or3s(eff != 1L, , ),
bor3(eff != 1L, , ))
expect_equal(or3s(efg != 9L, , ),
bor3(efg != 9L, , ))
expect_equal(or3s(efh != 0L, , h <= 0L),
bor3(efh != 0L, , h <= 0L))
expect_equal(or3s(efi != 1L, , a <= 1L),
bor3(efi != 1L, , a <= 1L))
expect_equal(or3s(efj != 9L, , g <= 9L),
bor3(efj != 9L, , g <= 9L))
expect_equal(or3s(efk != 0L, q %in% 1:4, ),
bor3(efk != 0L, q %in% 1:4, ))
expect_equal(or3s(efl != 1L, j %in% 1:4, ),
bor3(efl != 1L, j %in% 1:4, ))
expect_equal(or3s(efm != 9L, x %in% 1:4, ),
bor3(efm != 9L, x %in% 1:4, ))
expect_equal(or3s(efn != 0L, f %in% 1:4, o <= 0L),
bor3(efn != 0L, f %in% 1:4, o <= 0L))
expect_equal(or3s(efo != 1L, s %in% 1:4, c <= 1L),
bor3(efo != 1L, s %in% 1:4, c <= 1L))
expect_equal(or3s(efp != 9L, n %in% 1:4, e <= 9L),
bor3(efp != 9L, n %in% 1:4, e <= 9L))
expect_equal(or3s(efq != 0L, , ),
bor3(efq != 0L, , ))
expect_equal(or3s(efr != 1L, , ),
bor3(efr != 1L, , ))
expect_equal(or3s(efs != 9L, , ),
bor3(efs != 9L, , ))
expect_equal(or3s(eft != 0L, , k == 0L),
bor3(eft != 0L, , k == 0L))
expect_equal(or3s(efu != 1L, , d == 1L),
bor3(efu != 1L, , d == 1L))
expect_equal(or3s(efv != 9L, , t == 9L),
bor3(efv != 9L, , t == 9L))
expect_equal(or3s(efw != 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(efw != 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(efx != 1L, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(efx != 1L, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(efy != 9L, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(efy != 9L, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(efz != 0L, h %in% c(4L, -3L, 2L, 7L, 8L), m == 0L),
bor3(efz != 0L, h %in% c(4L, -3L, 2L, 7L, 8L), m == 0L))
expect_equal(or3s(ega != 1L, f %in% c(4L, -3L, 2L, 7L, 8L), d == 1L),
bor3(ega != 1L, f %in% c(4L, -3L, 2L, 7L, 8L), d == 1L))
expect_equal(or3s(egb != 9L, a %in% c(4L, -3L, 2L, 7L, 8L), t == 9L),
bor3(egb != 9L, a %in% c(4L, -3L, 2L, 7L, 8L), t == 9L))
expect_equal(or3s(egc != 0L, , ),
bor3(egc != 0L, , ))
expect_equal(or3s(egd != 1L, , ),
bor3(egd != 1L, , ))
expect_equal(or3s(ege != 9L, , ),
bor3(ege != 9L, , ))
expect_equal(or3s(egf != 0L, , y == 0L),
bor3(egf != 0L, , y == 0L))
expect_equal(or3s(egg != 1L, , w == 1L),
bor3(egg != 1L, , w == 1L))
expect_equal(or3s(egh != 9L, , c == 9L),
bor3(egh != 9L, , c == 9L))
expect_equal(or3s(egi != 0L, d %in% 1:4, ),
bor3(egi != 0L, d %in% 1:4, ))
expect_equal(or3s(egj != 1L, b %in% 1:4, ),
bor3(egj != 1L, b %in% 1:4, ))
expect_equal(or3s(egk != 9L, z %in% 1:4, ),
bor3(egk != 9L, z %in% 1:4, ))
expect_equal(or3s(egl != 0L, q %in% 1:4, c == 0L),
bor3(egl != 0L, q %in% 1:4, c == 0L))
expect_equal(or3s(egm != 1L, d %in% 1:4, v == 1L),
bor3(egm != 1L, d %in% 1:4, v == 1L))
expect_equal(or3s(egn != 9L, k %in% 1:4, a == 9L),
bor3(egn != 9L, k %in% 1:4, a == 9L))
expect_equal(or3s(ego != 0L, , ),
bor3(ego != 0L, , ))
expect_equal(or3s(egp != 1L, , ),
bor3(egp != 1L, , ))
expect_equal(or3s(egq != 9L, , ),
bor3(egq != 9L, , ))
expect_equal(or3s(egr != 0L, , f > 0L),
bor3(egr != 0L, , f > 0L))
expect_equal(or3s(egs != 1L, , w > 1L),
bor3(egs != 1L, , w > 1L))
expect_equal(or3s(egt != 9L, , c > 9L),
bor3(egt != 9L, , c > 9L))
expect_equal(or3s(egu != 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(egu != 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(egv != 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(egv != 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(egw != 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(egw != 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(egx != 0L, e %in% c(4L, -3L, 2L, 7L, 8L), v > 0L),
bor3(egx != 0L, e %in% c(4L, -3L, 2L, 7L, 8L), v > 0L))
expect_equal(or3s(egy != 1L, n %in% c(4L, -3L, 2L, 7L, 8L), w > 1L),
bor3(egy != 1L, n %in% c(4L, -3L, 2L, 7L, 8L), w > 1L))
expect_equal(or3s(egz != 9L, u %in% c(4L, -3L, 2L, 7L, 8L), h > 9L),
bor3(egz != 9L, u %in% c(4L, -3L, 2L, 7L, 8L), h > 9L))
expect_equal(or3s(eha != 0L, , ),
bor3(eha != 0L, , ))
expect_equal(or3s(ehb != 1L, , ),
bor3(ehb != 1L, , ))
expect_equal(or3s(ehc != 9L, , ),
bor3(ehc != 9L, , ))
expect_equal(or3s(ehd != 0L, , l > 0L),
bor3(ehd != 0L, , l > 0L))
expect_equal(or3s(ehe != 1L, , q > 1L),
bor3(ehe != 1L, , q > 1L))
expect_equal(or3s(ehf != 9L, , r > 9L),
bor3(ehf != 9L, , r > 9L))
expect_equal(or3s(ehg != 0L, g %in% 1:4, ),
bor3(ehg != 0L, g %in% 1:4, ))
expect_equal(or3s(ehh != 1L, h %in% 1:4, ),
bor3(ehh != 1L, h %in% 1:4, ))
expect_equal(or3s(ehi != 9L, x %in% 1:4, ),
bor3(ehi != 9L, x %in% 1:4, ))
expect_equal(or3s(ehj != 0L, z %in% 1:4, k > 0L),
bor3(ehj != 0L, z %in% 1:4, k > 0L))
expect_equal(or3s(ehk != 1L, p %in% 1:4, p > 1L),
bor3(ehk != 1L, p %in% 1:4, p > 1L))
expect_equal(or3s(ehl != 9L, o %in% 1:4, i > 9L),
bor3(ehl != 9L, o %in% 1:4, i > 9L))
expect_equal(or3s(ehm != 0L, , ),
bor3(ehm != 0L, , ))
expect_equal(or3s(ehn != 1L, , ),
bor3(ehn != 1L, , ))
expect_equal(or3s(eho != 9L, , ),
bor3(eho != 9L, , ))
expect_equal(or3s(ehp != 0L, , n >= 0L),
bor3(ehp != 0L, , n >= 0L))
expect_equal(or3s(ehq != 1L, , n >= 1L),
bor3(ehq != 1L, , n >= 1L))
expect_equal(or3s(ehr != 9L, , x >= 9L),
bor3(ehr != 9L, , x >= 9L))
expect_equal(or3s(ehs != 0L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ehs != 0L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(eht != 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(eht != 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ehu != 9L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ehu != 9L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ehv != 0L, y %in% c(4L, -3L, 2L, 7L, 8L), w >= 0L),
bor3(ehv != 0L, y %in% c(4L, -3L, 2L, 7L, 8L), w >= 0L))
expect_equal(or3s(ehw != 1L, w %in% c(4L, -3L, 2L, 7L, 8L), r >= 1L),
bor3(ehw != 1L, w %in% c(4L, -3L, 2L, 7L, 8L), r >= 1L))
expect_equal(or3s(ehx != 9L, o %in% c(4L, -3L, 2L, 7L, 8L), o >= 9L),
bor3(ehx != 9L, o %in% c(4L, -3L, 2L, 7L, 8L), o >= 9L))
expect_equal(or3s(ehy != 0L, , ),
bor3(ehy != 0L, , ))
expect_equal(or3s(ehz != 1L, , ),
bor3(ehz != 1L, , ))
expect_equal(or3s(eia != 9L, , ),
bor3(eia != 9L, , ))
expect_equal(or3s(eib != 0L, , u >= 0L),
bor3(eib != 0L, , u >= 0L))
expect_equal(or3s(eic != 1L, , d >= 1L),
bor3(eic != 1L, , d >= 1L))
expect_equal(or3s(eid != 9L, , t >= 9L),
bor3(eid != 9L, , t >= 9L))
expect_equal(or3s(eie != 0L, i %in% 1:4, ),
bor3(eie != 0L, i %in% 1:4, ))
expect_equal(or3s(eif != 1L, r %in% 1:4, ),
bor3(eif != 1L, r %in% 1:4, ))
expect_equal(or3s(eig != 9L, j %in% 1:4, ),
bor3(eig != 9L, j %in% 1:4, ))
expect_equal(or3s(eih != 0L, p %in% 1:4, u >= 0L),
bor3(eih != 0L, p %in% 1:4, u >= 0L))
expect_equal(or3s(eii != 1L, x %in% 1:4, k >= 1L),
bor3(eii != 1L, x %in% 1:4, k >= 1L))
expect_equal(or3s(eij != 9L, y %in% 1:4, n >= 9L),
bor3(eij != 9L, y %in% 1:4, n >= 9L))
expect_equal(or3s(eik != 0L, , ),
bor3(eik != 0L, , ))
expect_equal(or3s(eil != 1L, , ),
bor3(eil != 1L, , ))
expect_equal(or3s(eim != 9L, , ),
bor3(eim != 9L, , ))
expect_equal(or3s(ein != 0L, , logi_r),
bor3(ein != 0L, , logi_r))
expect_equal(or3s(eio != 1L, , logi_h),
bor3(eio != 1L, , logi_h))
expect_equal(or3s(eip != 9L, , logi_u),
bor3(eip != 9L, , logi_u))
expect_equal(or3s(eiq != 0L, z < 0L, ),
bor3(eiq != 0L, z < 0L, ))
expect_equal(or3s(eir != 1L, e < 1L, ),
bor3(eir != 1L, e < 1L, ))
expect_equal(or3s(eis != 9L, k < 9L, ),
bor3(eis != 9L, k < 9L, ))
expect_equal(or3s(eit != 0L, k < 0L, logi_q),
bor3(eit != 0L, k < 0L, logi_q))
expect_equal(or3s(eiu != 1L, n < 1L, logi_z),
bor3(eiu != 1L, n < 1L, logi_z))
expect_equal(or3s(eiv != 9L, l < 9L, logi_m),
bor3(eiv != 9L, l < 9L, logi_m))
expect_equal(or3s(eiw != 0L, , ),
bor3(eiw != 0L, , ))
expect_equal(or3s(eix != 1L, , ),
bor3(eix != 1L, , ))
expect_equal(or3s(eiy != 9L, , ),
bor3(eiy != 9L, , ))
expect_equal(or3s(eiz != 0L, , !logi_v),
bor3(eiz != 0L, , !logi_v))
expect_equal(or3s(eja != 1L, , !logi_e),
bor3(eja != 1L, , !logi_e))
expect_equal(or3s(ejb != 9L, , !logi_m),
bor3(ejb != 9L, , !logi_m))
expect_equal(or3s(ejc != 0L, v < 0L, ),
bor3(ejc != 0L, v < 0L, ))
expect_equal(or3s(ejd != 1L, q < 1L, ),
bor3(ejd != 1L, q < 1L, ))
expect_equal(or3s(eje != 9L, z < 9L, ),
bor3(eje != 9L, z < 9L, ))
expect_equal(or3s(ejf != 0L, b < 0L, !logi_u),
bor3(ejf != 0L, b < 0L, !logi_u))
expect_equal(or3s(ejg != 1L, f < 1L, !logi_t),
bor3(ejg != 1L, f < 1L, !logi_t))
expect_equal(or3s(ejh != 9L, l < 9L, !logi_u),
bor3(ejh != 9L, l < 9L, !logi_u))
expect_equal(or3s(eji != 0L, , ),
bor3(eji != 0L, , ))
expect_equal(or3s(ejj != 1L, , ),
bor3(ejj != 1L, , ))
expect_equal(or3s(ejk != 9L, , ),
bor3(ejk != 9L, , ))
expect_equal(or3s(ejl != 0L, , n != 0L),
bor3(ejl != 0L, , n != 0L))
expect_equal(or3s(ejm != 1L, , m != 1L),
bor3(ejm != 1L, , m != 1L))
expect_equal(or3s(ejn != 9L, , k != 9L),
bor3(ejn != 9L, , k != 9L))
expect_equal(or3s(ejo != 0L, l < 0L, ),
bor3(ejo != 0L, l < 0L, ))
expect_equal(or3s(ejp != 1L, z < 1L, ),
bor3(ejp != 1L, z < 1L, ))
expect_equal(or3s(ejq != 9L, u < 9L, ),
bor3(ejq != 9L, u < 9L, ))
expect_equal(or3s(ejr != 0L, e < 0L, v != 0L),
bor3(ejr != 0L, e < 0L, v != 0L))
expect_equal(or3s(ejs != 1L, u < 1L, z != 1L),
bor3(ejs != 1L, u < 1L, z != 1L))
expect_equal(or3s(ejt != 9L, w < 9L, u != 9L),
bor3(ejt != 9L, w < 9L, u != 9L))
expect_equal(or3s(eju != 0L, , ),
bor3(eju != 0L, , ))
expect_equal(or3s(ejv != 1L, , ),
bor3(ejv != 1L, , ))
expect_equal(or3s(ejw != 9L, , ),
bor3(ejw != 9L, , ))
expect_equal(or3s(ejx != 0L, , j %between% c(-1L, 1L)),
bor3(ejx != 0L, , j %between% c(-1L, 1L)))
expect_equal(or3s(ejy != 1L, , h %between% c(-1L, 1L)),
bor3(ejy != 1L, , h %between% c(-1L, 1L)))
expect_equal(or3s(ejz != 9L, , k %between% c(-1L, 1L)),
bor3(ejz != 9L, , k %between% c(-1L, 1L)))
expect_equal(or3s(eka != 0L, x < 0L, ),
bor3(eka != 0L, x < 0L, ))
expect_equal(or3s(ekb != 1L, q < 1L, ),
bor3(ekb != 1L, q < 1L, ))
expect_equal(or3s(ekc != 9L, p < 9L, ),
bor3(ekc != 9L, p < 9L, ))
expect_equal(or3s(ekd != 0L, q < 0L, g %between% c(-1L, 1L)),
bor3(ekd != 0L, q < 0L, g %between% c(-1L, 1L)))
expect_equal(or3s(eke != 1L, b < 1L, y %between% c(-1L, 1L)),
bor3(eke != 1L, b < 1L, y %between% c(-1L, 1L)))
expect_equal(or3s(ekf != 9L, y < 9L, j %between% c(-1L, 1L)),
bor3(ekf != 9L, y < 9L, j %between% c(-1L, 1L)))
expect_equal(or3s(ekg != 0L, , ),
bor3(ekg != 0L, , ))
expect_equal(or3s(ekh != 1L, , ),
bor3(ekh != 1L, , ))
expect_equal(or3s(eki != 9L, , ),
bor3(eki != 9L, , ))
expect_equal(or3s(ekj != 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ekj != 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ekk != 1L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ekk != 1L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ekl != 9L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ekl != 9L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ekm != 0L, u < 0L, ),
bor3(ekm != 0L, u < 0L, ))
expect_equal(or3s(ekn != 1L, z < 1L, ),
bor3(ekn != 1L, z < 1L, ))
expect_equal(or3s(eko != 9L, y < 9L, ),
bor3(eko != 9L, y < 9L, ))
expect_equal(or3s(ekp != 0L, a < 0L, o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ekp != 0L, a < 0L, o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ekq != 1L, g < 1L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ekq != 1L, g < 1L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ekr != 9L, g < 9L, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ekr != 9L, g < 9L, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(eks != 0L, , ),
bor3(eks != 0L, , ))
expect_equal(or3s(ekt != 1L, , ),
bor3(ekt != 1L, , ))
expect_equal(or3s(eku != 9L, , ),
bor3(eku != 9L, , ))
expect_equal(or3s(ekv != 0L, , n %in% 1:4),
bor3(ekv != 0L, , n %in% 1:4))
expect_equal(or3s(ekw != 1L, , a %in% 1:4),
bor3(ekw != 1L, , a %in% 1:4))
expect_equal(or3s(ekx != 9L, , g %in% 1:4),
bor3(ekx != 9L, , g %in% 1:4))
expect_equal(or3s(eky != 0L, d < 0L, ),
bor3(eky != 0L, d < 0L, ))
expect_equal(or3s(ekz != 1L, t < 1L, ),
bor3(ekz != 1L, t < 1L, ))
expect_equal(or3s(ela != 9L, y < 9L, ),
bor3(ela != 9L, y < 9L, ))
expect_equal(or3s(elb != 0L, p < 0L, z %in% 1:4),
bor3(elb != 0L, p < 0L, z %in% 1:4))
expect_equal(or3s(elc != 1L, p < 1L, b %in% 1:4),
bor3(elc != 1L, p < 1L, b %in% 1:4))
expect_equal(or3s(eld != 9L, n < 9L, e %in% 1:4),
bor3(eld != 9L, n < 9L, e %in% 1:4))
expect_equal(or3s(ele != 0L, , ),
bor3(ele != 0L, , ))
expect_equal(or3s(elf != 1L, , ),
bor3(elf != 1L, , ))
expect_equal(or3s(elg != 9L, , ),
bor3(elg != 9L, , ))
expect_equal(or3s(elh != 0L, , c < 0L),
bor3(elh != 0L, , c < 0L))
expect_equal(or3s(eli != 1L, , n < 1L),
bor3(eli != 1L, , n < 1L))
expect_equal(or3s(elj != 9L, , h < 9L),
bor3(elj != 9L, , h < 9L))
expect_equal(or3s(elk != 0L, p < 0L, ),
bor3(elk != 0L, p < 0L, ))
expect_equal(or3s(ell != 1L, w < 1L, ),
bor3(ell != 1L, w < 1L, ))
expect_equal(or3s(elm != 9L, s < 9L, ),
bor3(elm != 9L, s < 9L, ))
expect_equal(or3s(eln != 0L, r < 0L, z < 0L),
bor3(eln != 0L, r < 0L, z < 0L))
expect_equal(or3s(elo != 1L, q < 1L, u < 1L),
bor3(elo != 1L, q < 1L, u < 1L))
expect_equal(or3s(elp != 9L, q < 9L, p < 9L),
bor3(elp != 9L, q < 9L, p < 9L))
expect_equal(or3s(elq != 0L, , ),
bor3(elq != 0L, , ))
expect_equal(or3s(elr != 1L, , ),
bor3(elr != 1L, , ))
expect_equal(or3s(els != 9L, , ),
bor3(els != 9L, , ))
expect_equal(or3s(elt != 0L, , z <= 0L),
bor3(elt != 0L, , z <= 0L))
expect_equal(or3s(elu != 1L, , e <= 1L),
bor3(elu != 1L, , e <= 1L))
expect_equal(or3s(elv != 9L, , a <= 9L),
bor3(elv != 9L, , a <= 9L))
expect_equal(or3s(elw != 0L, a < 0L, ),
bor3(elw != 0L, a < 0L, ))
expect_equal(or3s(elx != 1L, u < 1L, ),
bor3(elx != 1L, u < 1L, ))
expect_equal(or3s(ely != 9L, x < 9L, ),
bor3(ely != 9L, x < 9L, ))
expect_equal(or3s(elz != 0L, r < 0L, h <= 0L),
bor3(elz != 0L, r < 0L, h <= 0L))
expect_equal(or3s(ema != 1L, j < 1L, n <= 1L),
bor3(ema != 1L, j < 1L, n <= 1L))
expect_equal(or3s(emb != 9L, v < 9L, x <= 9L),
bor3(emb != 9L, v < 9L, x <= 9L))
expect_equal(or3s(emc != 0L, , ),
bor3(emc != 0L, , ))
expect_equal(or3s(emd != 1L, , ),
bor3(emd != 1L, , ))
expect_equal(or3s(eme != 9L, , ),
bor3(eme != 9L, , ))
expect_equal(or3s(emf != 0L, , f == 0L),
bor3(emf != 0L, , f == 0L))
expect_equal(or3s(emg != 1L, , x == 1L),
bor3(emg != 1L, , x == 1L))
expect_equal(or3s(emh != 9L, , u == 9L),
bor3(emh != 9L, , u == 9L))
expect_equal(or3s(emi != 0L, x < 0L, ),
bor3(emi != 0L, x < 0L, ))
expect_equal(or3s(emj != 1L, l < 1L, ),
bor3(emj != 1L, l < 1L, ))
expect_equal(or3s(emk != 9L, r < 9L, ),
bor3(emk != 9L, r < 9L, ))
expect_equal(or3s(eml != 0L, g < 0L, z == 0L),
bor3(eml != 0L, g < 0L, z == 0L))
expect_equal(or3s(emm != 1L, j < 1L, n == 1L),
bor3(emm != 1L, j < 1L, n == 1L))
expect_equal(or3s(emn != 9L, v < 9L, u == 9L),
bor3(emn != 9L, v < 9L, u == 9L))
expect_equal(or3s(emo != 0L, , ),
bor3(emo != 0L, , ))
expect_equal(or3s(emp != 1L, , ),
bor3(emp != 1L, , ))
expect_equal(or3s(emq != 9L, , ),
bor3(emq != 9L, , ))
expect_equal(or3s(emr != 0L, , t > 0L),
bor3(emr != 0L, , t > 0L))
expect_equal(or3s(ems != 1L, , v > 1L),
bor3(ems != 1L, , v > 1L))
expect_equal(or3s(emt != 9L, , e > 9L),
bor3(emt != 9L, , e > 9L))
expect_equal(or3s(emu != 0L, m < 0L, ),
bor3(emu != 0L, m < 0L, ))
expect_equal(or3s(emv != 1L, i < 1L, ),
bor3(emv != 1L, i < 1L, ))
expect_equal(or3s(emw != 9L, w < 9L, ),
bor3(emw != 9L, w < 9L, ))
expect_equal(or3s(emx != 0L, y < 0L, o > 0L),
bor3(emx != 0L, y < 0L, o > 0L))
expect_equal(or3s(emy != 1L, x < 1L, d > 1L),
bor3(emy != 1L, x < 1L, d > 1L))
expect_equal(or3s(emz != 9L, x < 9L, s > 9L),
bor3(emz != 9L, x < 9L, s > 9L))
expect_equal(or3s(ena != 0L, , ),
bor3(ena != 0L, , ))
expect_equal(or3s(enb != 1L, , ),
bor3(enb != 1L, , ))
expect_equal(or3s(enc != 9L, , ),
bor3(enc != 9L, , ))
expect_equal(or3s(end != 0L, , i >= 0L),
bor3(end != 0L, , i >= 0L))
expect_equal(or3s(ene != 1L, , e >= 1L),
bor3(ene != 1L, , e >= 1L))
expect_equal(or3s(enf != 9L, , z >= 9L),
bor3(enf != 9L, , z >= 9L))
expect_equal(or3s(eng != 0L, q < 0L, ),
bor3(eng != 0L, q < 0L, ))
expect_equal(or3s(enh != 1L, z < 1L, ),
bor3(enh != 1L, z < 1L, ))
expect_equal(or3s(eni != 9L, s < 9L, ),
bor3(eni != 9L, s < 9L, ))
expect_equal(or3s(enj != 0L, w < 0L, v >= 0L),
bor3(enj != 0L, w < 0L, v >= 0L))
expect_equal(or3s(enk != 1L, j < 1L, t >= 1L),
bor3(enk != 1L, j < 1L, t >= 1L))
expect_equal(or3s(enl != 9L, d < 9L, i >= 9L),
bor3(enl != 9L, d < 9L, i >= 9L))
expect_equal(or3s(enm != 0L, , ),
bor3(enm != 0L, , ))
expect_equal(or3s(enn != 1L, , ),
bor3(enn != 1L, , ))
expect_equal(or3s(eno != 9L, , ),
bor3(eno != 9L, , ))
expect_equal(or3s(enp != 0L, , logi_k),
bor3(enp != 0L, , logi_k))
expect_equal(or3s(enq != 1L, , logi_i),
bor3(enq != 1L, , logi_i))
expect_equal(or3s(enr != 9L, , logi_i),
bor3(enr != 9L, , logi_i))
expect_equal(or3s(ens != 0L, e <= 0L, ),
bor3(ens != 0L, e <= 0L, ))
expect_equal(or3s(ent != 1L, f <= 1L, ),
bor3(ent != 1L, f <= 1L, ))
expect_equal(or3s(enu != 9L, q <= 9L, ),
bor3(enu != 9L, q <= 9L, ))
expect_equal(or3s(env != 0L, m <= 0L, logi_a),
bor3(env != 0L, m <= 0L, logi_a))
expect_equal(or3s(enw != 1L, z <= 1L, logi_c),
bor3(enw != 1L, z <= 1L, logi_c))
expect_equal(or3s(enx != 9L, k <= 9L, logi_c),
bor3(enx != 9L, k <= 9L, logi_c))
expect_equal(or3s(eny != 0L, , ),
bor3(eny != 0L, , ))
expect_equal(or3s(enz != 1L, , ),
bor3(enz != 1L, , ))
expect_equal(or3s(eoa != 9L, , ),
bor3(eoa != 9L, , ))
expect_equal(or3s(eob != 0L, , !logi_g),
bor3(eob != 0L, , !logi_g))
expect_equal(or3s(eoc != 1L, , !logi_e),
bor3(eoc != 1L, , !logi_e))
expect_equal(or3s(eod != 9L, , !logi_d),
bor3(eod != 9L, , !logi_d))
expect_equal(or3s(eoe != 0L, l <= 0L, ),
bor3(eoe != 0L, l <= 0L, ))
expect_equal(or3s(eof != 1L, l <= 1L, ),
bor3(eof != 1L, l <= 1L, ))
expect_equal(or3s(eog != 9L, a <= 9L, ),
bor3(eog != 9L, a <= 9L, ))
expect_equal(or3s(eoh != 0L, w <= 0L, !logi_f),
bor3(eoh != 0L, w <= 0L, !logi_f))
expect_equal(or3s(eoi != 1L, f <= 1L, !logi_n),
bor3(eoi != 1L, f <= 1L, !logi_n))
expect_equal(or3s(eoj != 9L, x <= 9L, !logi_m),
bor3(eoj != 9L, x <= 9L, !logi_m))
expect_equal(or3s(eok != 0L, , ),
bor3(eok != 0L, , ))
expect_equal(or3s(eol != 1L, , ),
bor3(eol != 1L, , ))
expect_equal(or3s(eom != 9L, , ),
bor3(eom != 9L, , ))
expect_equal(or3s(eon != 0L, , u != 0L),
bor3(eon != 0L, , u != 0L))
expect_equal(or3s(eoo != 1L, , z != 1L),
bor3(eoo != 1L, , z != 1L))
expect_equal(or3s(eop != 9L, , a != 9L),
bor3(eop != 9L, , a != 9L))
expect_equal(or3s(eoq != 0L, p <= 0L, ),
bor3(eoq != 0L, p <= 0L, ))
expect_equal(or3s(eor != 1L, a <= 1L, ),
bor3(eor != 1L, a <= 1L, ))
expect_equal(or3s(eos != 9L, q <= 9L, ),
bor3(eos != 9L, q <= 9L, ))
expect_equal(or3s(eot != 0L, b <= 0L, m != 0L),
bor3(eot != 0L, b <= 0L, m != 0L))
expect_equal(or3s(eou != 1L, g <= 1L, b != 1L),
bor3(eou != 1L, g <= 1L, b != 1L))
expect_equal(or3s(eov != 9L, k <= 9L, u != 9L),
bor3(eov != 9L, k <= 9L, u != 9L))
expect_equal(or3s(eow != 0L, , ),
bor3(eow != 0L, , ))
expect_equal(or3s(eox != 1L, , ),
bor3(eox != 1L, , ))
expect_equal(or3s(eoy != 9L, , ),
bor3(eoy != 9L, , ))
expect_equal(or3s(eoz != 0L, , u %between% c(-1L, 1L)),
bor3(eoz != 0L, , u %between% c(-1L, 1L)))
expect_equal(or3s(epa != 1L, , k %between% c(-1L, 1L)),
bor3(epa != 1L, , k %between% c(-1L, 1L)))
expect_equal(or3s(epb != 9L, , v %between% c(-1L, 1L)),
bor3(epb != 9L, , v %between% c(-1L, 1L)))
expect_equal(or3s(epc != 0L, e <= 0L, ),
bor3(epc != 0L, e <= 0L, ))
expect_equal(or3s(epd != 1L, m <= 1L, ),
bor3(epd != 1L, m <= 1L, ))
expect_equal(or3s(epe != 9L, r <= 9L, ),
bor3(epe != 9L, r <= 9L, ))
expect_equal(or3s(epf != 0L, o <= 0L, v %between% c(-1L, 1L)),
bor3(epf != 0L, o <= 0L, v %between% c(-1L, 1L)))
expect_equal(or3s(epg != 1L, d <= 1L, i %between% c(-1L, 1L)),
bor3(epg != 1L, d <= 1L, i %between% c(-1L, 1L)))
expect_equal(or3s(eph != 9L, n <= 9L, w %between% c(-1L, 1L)),
bor3(eph != 9L, n <= 9L, w %between% c(-1L, 1L)))
expect_equal(or3s(epi != 0L, , ),
bor3(epi != 0L, , ))
expect_equal(or3s(epj != 1L, , ),
bor3(epj != 1L, , ))
expect_equal(or3s(epk != 9L, , ),
bor3(epk != 9L, , ))
expect_equal(or3s(epl != 0L, , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(epl != 0L, , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(epm != 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(epm != 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(epn != 9L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(epn != 9L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(epo != 0L, p <= 0L, ),
bor3(epo != 0L, p <= 0L, ))
expect_equal(or3s(epp != 1L, j <= 1L, ),
bor3(epp != 1L, j <= 1L, ))
expect_equal(or3s(epq != 9L, j <= 9L, ),
bor3(epq != 9L, j <= 9L, ))
expect_equal(or3s(epr != 0L, h <= 0L, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(epr != 0L, h <= 0L, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(eps != 1L, s <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(eps != 1L, s <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ept != 9L, h <= 9L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ept != 9L, h <= 9L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(epu != 0L, , ),
bor3(epu != 0L, , ))
expect_equal(or3s(epv != 1L, , ),
bor3(epv != 1L, , ))
expect_equal(or3s(epw != 9L, , ),
bor3(epw != 9L, , ))
expect_equal(or3s(epx != 0L, , s %in% 1:4),
bor3(epx != 0L, , s %in% 1:4))
expect_equal(or3s(epy != 1L, , l %in% 1:4),
bor3(epy != 1L, , l %in% 1:4))
expect_equal(or3s(epz != 9L, , l %in% 1:4),
bor3(epz != 9L, , l %in% 1:4))
expect_equal(or3s(eqa != 0L, t <= 0L, ),
bor3(eqa != 0L, t <= 0L, ))
expect_equal(or3s(eqb != 1L, t <= 1L, ),
bor3(eqb != 1L, t <= 1L, ))
expect_equal(or3s(eqc != 9L, o <= 9L, ),
bor3(eqc != 9L, o <= 9L, ))
expect_equal(or3s(eqd != 0L, z <= 0L, j %in% 1:4),
bor3(eqd != 0L, z <= 0L, j %in% 1:4))
expect_equal(or3s(eqe != 1L, p <= 1L, w %in% 1:4),
bor3(eqe != 1L, p <= 1L, w %in% 1:4))
expect_equal(or3s(eqf != 9L, t <= 9L, h %in% 1:4),
bor3(eqf != 9L, t <= 9L, h %in% 1:4))
expect_equal(or3s(eqg != 0L, , ),
bor3(eqg != 0L, , ))
expect_equal(or3s(eqh != 1L, , ),
bor3(eqh != 1L, , ))
expect_equal(or3s(eqi != 9L, , ),
bor3(eqi != 9L, , ))
expect_equal(or3s(eqj != 0L, , r < 0L),
bor3(eqj != 0L, , r < 0L))
expect_equal(or3s(eqk != 1L, , s < 1L),
bor3(eqk != 1L, , s < 1L))
expect_equal(or3s(eql != 9L, , w < 9L),
bor3(eql != 9L, , w < 9L))
expect_equal(or3s(eqm != 0L, i <= 0L, ),
bor3(eqm != 0L, i <= 0L, ))
expect_equal(or3s(eqn != 1L, m <= 1L, ),
bor3(eqn != 1L, m <= 1L, ))
expect_equal(or3s(eqo != 9L, r <= 9L, ),
bor3(eqo != 9L, r <= 9L, ))
expect_equal(or3s(eqp != 0L, d <= 0L, f < 0L),
bor3(eqp != 0L, d <= 0L, f < 0L))
expect_equal(or3s(eqq != 1L, f <= 1L, c < 1L),
bor3(eqq != 1L, f <= 1L, c < 1L))
expect_equal(or3s(eqr != 9L, w <= 9L, a < 9L),
bor3(eqr != 9L, w <= 9L, a < 9L))
expect_equal(or3s(eqs != 0L, , ),
bor3(eqs != 0L, , ))
expect_equal(or3s(eqt != 1L, , ),
bor3(eqt != 1L, , ))
expect_equal(or3s(equ != 9L, , ),
bor3(equ != 9L, , ))
expect_equal(or3s(eqv != 0L, , f <= 0L),
bor3(eqv != 0L, , f <= 0L))
expect_equal(or3s(eqw != 1L, , a <= 1L),
bor3(eqw != 1L, , a <= 1L))
expect_equal(or3s(eqx != 9L, , s <= 9L),
bor3(eqx != 9L, , s <= 9L))
expect_equal(or3s(eqy != 0L, b <= 0L, ),
bor3(eqy != 0L, b <= 0L, ))
expect_equal(or3s(eqz != 1L, q <= 1L, ),
bor3(eqz != 1L, q <= 1L, ))
expect_equal(or3s(era != 9L, a <= 9L, ),
bor3(era != 9L, a <= 9L, ))
expect_equal(or3s(erb != 0L, l <= 0L, v <= 0L),
bor3(erb != 0L, l <= 0L, v <= 0L))
expect_equal(or3s(erc != 1L, j <= 1L, z <= 1L),
bor3(erc != 1L, j <= 1L, z <= 1L))
expect_equal(or3s(erd != 9L, r <= 9L, r <= 9L),
bor3(erd != 9L, r <= 9L, r <= 9L))
expect_equal(or3s(ere != 0L, , ),
bor3(ere != 0L, , ))
expect_equal(or3s(erf != 1L, , ),
bor3(erf != 1L, , ))
expect_equal(or3s(erg != 9L, , ),
bor3(erg != 9L, , ))
expect_equal(or3s(erh != 0L, , u == 0L),
bor3(erh != 0L, , u == 0L))
expect_equal(or3s(eri != 1L, , w == 1L),
bor3(eri != 1L, , w == 1L))
expect_equal(or3s(erj != 9L, , x == 9L),
bor3(erj != 9L, , x == 9L))
expect_equal(or3s(erk != 0L, m <= 0L, ),
bor3(erk != 0L, m <= 0L, ))
expect_equal(or3s(erl != 1L, m <= 1L, ),
bor3(erl != 1L, m <= 1L, ))
expect_equal(or3s(erm != 9L, l <= 9L, ),
bor3(erm != 9L, l <= 9L, ))
expect_equal(or3s(ern != 0L, b <= 0L, t == 0L),
bor3(ern != 0L, b <= 0L, t == 0L))
expect_equal(or3s(ero != 1L, x <= 1L, j == 1L),
bor3(ero != 1L, x <= 1L, j == 1L))
expect_equal(or3s(erp != 9L, y <= 9L, e == 9L),
bor3(erp != 9L, y <= 9L, e == 9L))
expect_equal(or3s(erq != 0L, , ),
bor3(erq != 0L, , ))
expect_equal(or3s(err != 1L, , ),
bor3(err != 1L, , ))
expect_equal(or3s(ers != 9L, , ),
bor3(ers != 9L, , ))
expect_equal(or3s(ert != 0L, , v > 0L),
bor3(ert != 0L, , v > 0L))
expect_equal(or3s(eru != 1L, , t > 1L),
bor3(eru != 1L, , t > 1L))
expect_equal(or3s(erv != 9L, , y > 9L),
bor3(erv != 9L, , y > 9L))
expect_equal(or3s(erw != 0L, l <= 0L, ),
bor3(erw != 0L, l <= 0L, ))
expect_equal(or3s(erx != 1L, j <= 1L, ),
bor3(erx != 1L, j <= 1L, ))
expect_equal(or3s(ery != 9L, h <= 9L, ),
bor3(ery != 9L, h <= 9L, ))
expect_equal(or3s(erz != 0L, v <= 0L, a > 0L),
bor3(erz != 0L, v <= 0L, a > 0L))
expect_equal(or3s(esa != 1L, o <= 1L, r > 1L),
bor3(esa != 1L, o <= 1L, r > 1L))
expect_equal(or3s(esb != 9L, p <= 9L, e > 9L),
bor3(esb != 9L, p <= 9L, e > 9L))
expect_equal(or3s(esc != 0L, , ),
bor3(esc != 0L, , ))
expect_equal(or3s(esd != 1L, , ),
bor3(esd != 1L, , ))
expect_equal(or3s(ese != 9L, , ),
bor3(ese != 9L, , ))
expect_equal(or3s(esf != 0L, , i >= 0L),
bor3(esf != 0L, , i >= 0L))
expect_equal(or3s(esg != 1L, , i >= 1L),
bor3(esg != 1L, , i >= 1L))
expect_equal(or3s(esh != 9L, , p >= 9L),
bor3(esh != 9L, , p >= 9L))
expect_equal(or3s(esi != 0L, h <= 0L, ),
bor3(esi != 0L, h <= 0L, ))
expect_equal(or3s(esj != 1L, z <= 1L, ),
bor3(esj != 1L, z <= 1L, ))
expect_equal(or3s(esk != 9L, v <= 9L, ),
bor3(esk != 9L, v <= 9L, ))
expect_equal(or3s(esl != 0L, h <= 0L, d >= 0L),
bor3(esl != 0L, h <= 0L, d >= 0L))
expect_equal(or3s(esm != 1L, l <= 1L, z >= 1L),
bor3(esm != 1L, l <= 1L, z >= 1L))
expect_equal(or3s(esn != 9L, n <= 9L, q >= 9L),
bor3(esn != 9L, n <= 9L, q >= 9L))
expect_equal(or3s(eso != 0L, , ),
bor3(eso != 0L, , ))
expect_equal(or3s(esp != 1L, , ),
bor3(esp != 1L, , ))
expect_equal(or3s(esq != 9L, , ),
bor3(esq != 9L, , ))
expect_equal(or3s(esr != 0L, , logi_g),
bor3(esr != 0L, , logi_g))
expect_equal(or3s(ess != 1L, , logi_i),
bor3(ess != 1L, , logi_i))
expect_equal(or3s(est != 9L, , logi_k),
bor3(est != 9L, , logi_k))
expect_equal(or3s(esu != 0L, m == 0L, ),
bor3(esu != 0L, m == 0L, ))
expect_equal(or3s(esv != 1L, y == 1L, ),
bor3(esv != 1L, y == 1L, ))
expect_equal(or3s(esw != 9L, l == 9L, ),
bor3(esw != 9L, l == 9L, ))
expect_equal(or3s(esx != 0L, w == 0L, logi_g),
bor3(esx != 0L, w == 0L, logi_g))
expect_equal(or3s(esy != 1L, i == 1L, logi_d),
bor3(esy != 1L, i == 1L, logi_d))
expect_equal(or3s(esz != 9L, z == 9L, logi_o),
bor3(esz != 9L, z == 9L, logi_o))
expect_equal(or3s(eta != 0L, , ),
bor3(eta != 0L, , ))
expect_equal(or3s(etb != 1L, , ),
bor3(etb != 1L, , ))
expect_equal(or3s(etc != 9L, , ),
bor3(etc != 9L, , ))
expect_equal(or3s(etd != 0L, , !logi_v),
bor3(etd != 0L, , !logi_v))
expect_equal(or3s(ete != 1L, , !logi_r),
bor3(ete != 1L, , !logi_r))
expect_equal(or3s(etf != 9L, , !logi_o),
bor3(etf != 9L, , !logi_o))
expect_equal(or3s(etg != 0L, p == 0L, ),
bor3(etg != 0L, p == 0L, ))
expect_equal(or3s(eth != 1L, i == 1L, ),
bor3(eth != 1L, i == 1L, ))
expect_equal(or3s(eti != 9L, q == 9L, ),
bor3(eti != 9L, q == 9L, ))
expect_equal(or3s(etj != 0L, t == 0L, !logi_m),
bor3(etj != 0L, t == 0L, !logi_m))
expect_equal(or3s(etk != 1L, n == 1L, !logi_z),
bor3(etk != 1L, n == 1L, !logi_z))
expect_equal(or3s(etl != 9L, r == 9L, !logi_a),
bor3(etl != 9L, r == 9L, !logi_a))
expect_equal(or3s(etm != 0L, , ),
bor3(etm != 0L, , ))
expect_equal(or3s(etn != 1L, , ),
bor3(etn != 1L, , ))
expect_equal(or3s(eto != 9L, , ),
bor3(eto != 9L, , ))
expect_equal(or3s(etp != 0L, , d != 0L),
bor3(etp != 0L, , d != 0L))
expect_equal(or3s(etq != 1L, , e != 1L),
bor3(etq != 1L, , e != 1L))
expect_equal(or3s(etr != 9L, , v != 9L),
bor3(etr != 9L, , v != 9L))
expect_equal(or3s(ets != 0L, q == 0L, ),
bor3(ets != 0L, q == 0L, ))
expect_equal(or3s(ett != 1L, m == 1L, ),
bor3(ett != 1L, m == 1L, ))
expect_equal(or3s(etu != 9L, t == 9L, ),
bor3(etu != 9L, t == 9L, ))
expect_equal(or3s(etv != 0L, b == 0L, u != 0L),
bor3(etv != 0L, b == 0L, u != 0L))
expect_equal(or3s(etw != 1L, n == 1L, g != 1L),
bor3(etw != 1L, n == 1L, g != 1L))
expect_equal(or3s(etx != 9L, j == 9L, g != 9L),
bor3(etx != 9L, j == 9L, g != 9L))
expect_equal(or3s(ety != 0L, , ),
bor3(ety != 0L, , ))
expect_equal(or3s(etz != 1L, , ),
bor3(etz != 1L, , ))
expect_equal(or3s(eua != 9L, , ),
bor3(eua != 9L, , ))
expect_equal(or3s(eub != 0L, , n %between% c(-1L, 1L)),
bor3(eub != 0L, , n %between% c(-1L, 1L)))
expect_equal(or3s(euc != 1L, , b %between% c(-1L, 1L)),
bor3(euc != 1L, , b %between% c(-1L, 1L)))
expect_equal(or3s(eud != 9L, , w %between% c(-1L, 1L)),
bor3(eud != 9L, , w %between% c(-1L, 1L)))
expect_equal(or3s(eue != 0L, o == 0L, ),
bor3(eue != 0L, o == 0L, ))
expect_equal(or3s(euf != 1L, t == 1L, ),
bor3(euf != 1L, t == 1L, ))
expect_equal(or3s(eug != 9L, o == 9L, ),
bor3(eug != 9L, o == 9L, ))
expect_equal(or3s(euh != 0L, n == 0L, u %between% c(-1L, 1L)),
bor3(euh != 0L, n == 0L, u %between% c(-1L, 1L)))
expect_equal(or3s(eui != 1L, b == 1L, b %between% c(-1L, 1L)),
bor3(eui != 1L, b == 1L, b %between% c(-1L, 1L)))
expect_equal(or3s(euj != 9L, c == 9L, c %between% c(-1L, 1L)),
bor3(euj != 9L, c == 9L, c %between% c(-1L, 1L)))
expect_equal(or3s(euk != 0L, , ),
bor3(euk != 0L, , ))
expect_equal(or3s(eul != 1L, , ),
bor3(eul != 1L, , ))
expect_equal(or3s(eum != 9L, , ),
bor3(eum != 9L, , ))
expect_equal(or3s(eun != 0L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(eun != 0L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(euo != 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(euo != 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(eup != 9L, , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(eup != 9L, , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(euq != 0L, y == 0L, ),
bor3(euq != 0L, y == 0L, ))
expect_equal(or3s(eur != 1L, q == 1L, ),
bor3(eur != 1L, q == 1L, ))
expect_equal(or3s(eus != 9L, x == 9L, ),
bor3(eus != 9L, x == 9L, ))
expect_equal(or3s(eut != 0L, k == 0L, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(eut != 0L, k == 0L, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(euu != 1L, g == 1L, o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(euu != 1L, g == 1L, o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(euv != 9L, g == 9L, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(euv != 9L, g == 9L, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(euw != 0L, , ),
bor3(euw != 0L, , ))
expect_equal(or3s(eux != 1L, , ),
bor3(eux != 1L, , ))
expect_equal(or3s(euy != 9L, , ),
bor3(euy != 9L, , ))
expect_equal(or3s(euz != 0L, , f %in% 1:4),
bor3(euz != 0L, , f %in% 1:4))
expect_equal(or3s(eva != 1L, , r %in% 1:4),
bor3(eva != 1L, , r %in% 1:4))
expect_equal(or3s(evb != 9L, , l %in% 1:4),
bor3(evb != 9L, , l %in% 1:4))
expect_equal(or3s(evc != 0L, s == 0L, ),
bor3(evc != 0L, s == 0L, ))
expect_equal(or3s(evd != 1L, m == 1L, ),
bor3(evd != 1L, m == 1L, ))
expect_equal(or3s(eve != 9L, a == 9L, ),
bor3(eve != 9L, a == 9L, ))
expect_equal(or3s(evf != 0L, t == 0L, h %in% 1:4),
bor3(evf != 0L, t == 0L, h %in% 1:4))
expect_equal(or3s(evg != 1L, p == 1L, g %in% 1:4),
bor3(evg != 1L, p == 1L, g %in% 1:4))
expect_equal(or3s(evh != 9L, i == 9L, b %in% 1:4),
bor3(evh != 9L, i == 9L, b %in% 1:4))
expect_equal(or3s(evi != 0L, , ),
bor3(evi != 0L, , ))
expect_equal(or3s(evj != 1L, , ),
bor3(evj != 1L, , ))
expect_equal(or3s(evk != 9L, , ),
bor3(evk != 9L, , ))
expect_equal(or3s(evl != 0L, , k < 0L),
bor3(evl != 0L, , k < 0L))
expect_equal(or3s(evm != 1L, , p < 1L),
bor3(evm != 1L, , p < 1L))
expect_equal(or3s(evn != 9L, , s < 9L),
bor3(evn != 9L, , s < 9L))
expect_equal(or3s(evo != 0L, b == 0L, ),
bor3(evo != 0L, b == 0L, ))
expect_equal(or3s(evp != 1L, o == 1L, ),
bor3(evp != 1L, o == 1L, ))
expect_equal(or3s(evq != 9L, u == 9L, ),
bor3(evq != 9L, u == 9L, ))
expect_equal(or3s(evr != 0L, r == 0L, o < 0L),
bor3(evr != 0L, r == 0L, o < 0L))
expect_equal(or3s(evs != 1L, q == 1L, w < 1L),
bor3(evs != 1L, q == 1L, w < 1L))
expect_equal(or3s(evt != 9L, q == 9L, p < 9L),
bor3(evt != 9L, q == 9L, p < 9L))
expect_equal(or3s(evu != 0L, , ),
bor3(evu != 0L, , ))
expect_equal(or3s(evv != 1L, , ),
bor3(evv != 1L, , ))
expect_equal(or3s(evw != 9L, , ),
bor3(evw != 9L, , ))
expect_equal(or3s(evx != 0L, , i <= 0L),
bor3(evx != 0L, , i <= 0L))
expect_equal(or3s(evy != 1L, , n <= 1L),
bor3(evy != 1L, , n <= 1L))
expect_equal(or3s(evz != 9L, , v <= 9L),
bor3(evz != 9L, , v <= 9L))
expect_equal(or3s(ewa != 0L, t == 0L, ),
bor3(ewa != 0L, t == 0L, ))
expect_equal(or3s(ewb != 1L, p == 1L, ),
bor3(ewb != 1L, p == 1L, ))
expect_equal(or3s(ewc != 9L, m == 9L, ),
bor3(ewc != 9L, m == 9L, ))
expect_equal(or3s(ewd != 0L, j == 0L, w <= 0L),
bor3(ewd != 0L, j == 0L, w <= 0L))
expect_equal(or3s(ewe != 1L, e == 1L, k <= 1L),
bor3(ewe != 1L, e == 1L, k <= 1L))
expect_equal(or3s(ewf != 9L, u == 9L, e <= 9L),
bor3(ewf != 9L, u == 9L, e <= 9L))
expect_equal(or3s(ewg != 0L, , ),
bor3(ewg != 0L, , ))
expect_equal(or3s(ewh != 1L, , ),
bor3(ewh != 1L, , ))
expect_equal(or3s(ewi != 9L, , ),
bor3(ewi != 9L, , ))
expect_equal(or3s(ewj != 0L, , y == 0L),
bor3(ewj != 0L, , y == 0L))
expect_equal(or3s(ewk != 1L, , a == 1L),
bor3(ewk != 1L, , a == 1L))
expect_equal(or3s(ewl != 9L, , j == 9L),
bor3(ewl != 9L, , j == 9L))
expect_equal(or3s(ewm != 0L, z == 0L, ),
bor3(ewm != 0L, z == 0L, ))
expect_equal(or3s(ewn != 1L, n == 1L, ),
bor3(ewn != 1L, n == 1L, ))
expect_equal(or3s(ewo != 9L, d == 9L, ),
bor3(ewo != 9L, d == 9L, ))
expect_equal(or3s(ewp != 0L, x == 0L, v == 0L),
bor3(ewp != 0L, x == 0L, v == 0L))
expect_equal(or3s(ewq != 1L, a == 1L, j == 1L),
bor3(ewq != 1L, a == 1L, j == 1L))
expect_equal(or3s(ewr != 9L, x == 9L, x == 9L),
bor3(ewr != 9L, x == 9L, x == 9L))
expect_equal(or3s(ews != 0L, , ),
bor3(ews != 0L, , ))
expect_equal(or3s(ewt != 1L, , ),
bor3(ewt != 1L, , ))
expect_equal(or3s(ewu != 9L, , ),
bor3(ewu != 9L, , ))
expect_equal(or3s(ewv != 0L, , b > 0L),
bor3(ewv != 0L, , b > 0L))
expect_equal(or3s(eww != 1L, , j > 1L),
bor3(eww != 1L, , j > 1L))
expect_equal(or3s(ewx != 9L, , j > 9L),
bor3(ewx != 9L, , j > 9L))
expect_equal(or3s(ewy != 0L, h == 0L, ),
bor3(ewy != 0L, h == 0L, ))
expect_equal(or3s(ewz != 1L, o == 1L, ),
bor3(ewz != 1L, o == 1L, ))
expect_equal(or3s(exa != 9L, t == 9L, ),
bor3(exa != 9L, t == 9L, ))
expect_equal(or3s(exb != 0L, o == 0L, f > 0L),
bor3(exb != 0L, o == 0L, f > 0L))
expect_equal(or3s(exc != 1L, d == 1L, t > 1L),
bor3(exc != 1L, d == 1L, t > 1L))
expect_equal(or3s(exd != 9L, q == 9L, l > 9L),
bor3(exd != 9L, q == 9L, l > 9L))
expect_equal(or3s(exe != 0L, , ),
bor3(exe != 0L, , ))
expect_equal(or3s(exf != 1L, , ),
bor3(exf != 1L, , ))
expect_equal(or3s(exg != 9L, , ),
bor3(exg != 9L, , ))
expect_equal(or3s(exh != 0L, , b >= 0L),
bor3(exh != 0L, , b >= 0L))
expect_equal(or3s(exi != 1L, , k >= 1L),
bor3(exi != 1L, , k >= 1L))
expect_equal(or3s(exj != 9L, , e >= 9L),
bor3(exj != 9L, , e >= 9L))
expect_equal(or3s(exk != 0L, g == 0L, ),
bor3(exk != 0L, g == 0L, ))
expect_equal(or3s(exl != 1L, a == 1L, ),
bor3(exl != 1L, a == 1L, ))
expect_equal(or3s(exm != 9L, h == 9L, ),
bor3(exm != 9L, h == 9L, ))
expect_equal(or3s(exn != 0L, u == 0L, t >= 0L),
bor3(exn != 0L, u == 0L, t >= 0L))
expect_equal(or3s(exo != 1L, d == 1L, w >= 1L),
bor3(exo != 1L, d == 1L, w >= 1L))
expect_equal(or3s(exp != 9L, z == 9L, y >= 9L),
bor3(exp != 9L, z == 9L, y >= 9L))
expect_equal(or3s(exq != 0L, , ),
bor3(exq != 0L, , ))
expect_equal(or3s(exr != 1L, , ),
bor3(exr != 1L, , ))
expect_equal(or3s(exs != 9L, , ),
bor3(exs != 9L, , ))
expect_equal(or3s(ext != 0L, , logi_v),
bor3(ext != 0L, , logi_v))
expect_equal(or3s(exu != 1L, , logi_a),
bor3(exu != 1L, , logi_a))
expect_equal(or3s(exv != 9L, , logi_h),
bor3(exv != 9L, , logi_h))
expect_equal(or3s(exw != 0L, d > 0L, ),
bor3(exw != 0L, d > 0L, ))
expect_equal(or3s(exx != 1L, m > 1L, ),
bor3(exx != 1L, m > 1L, ))
expect_equal(or3s(exy != 9L, c > 9L, ),
bor3(exy != 9L, c > 9L, ))
expect_equal(or3s(exz != 0L, f > 0L, logi_w),
bor3(exz != 0L, f > 0L, logi_w))
expect_equal(or3s(eya != 1L, d > 1L, logi_x),
bor3(eya != 1L, d > 1L, logi_x))
expect_equal(or3s(eyb != 9L, h > 9L, logi_i),
bor3(eyb != 9L, h > 9L, logi_i))
expect_equal(or3s(eyc != 0L, , ),
bor3(eyc != 0L, , ))
expect_equal(or3s(eyd != 1L, , ),
bor3(eyd != 1L, , ))
expect_equal(or3s(eye != 9L, , ),
bor3(eye != 9L, , ))
expect_equal(or3s(eyf != 0L, , !logi_e),
bor3(eyf != 0L, , !logi_e))
expect_equal(or3s(eyg != 1L, , !logi_a),
bor3(eyg != 1L, , !logi_a))
expect_equal(or3s(eyh != 9L, , !logi_o),
bor3(eyh != 9L, , !logi_o))
expect_equal(or3s(eyi != 0L, s > 0L, ),
bor3(eyi != 0L, s > 0L, ))
expect_equal(or3s(eyj != 1L, n > 1L, ),
bor3(eyj != 1L, n > 1L, ))
expect_equal(or3s(eyk != 9L, c > 9L, ),
bor3(eyk != 9L, c > 9L, ))
expect_equal(or3s(eyl != 0L, m > 0L, !logi_v),
bor3(eyl != 0L, m > 0L, !logi_v))
expect_equal(or3s(eym != 1L, t > 1L, !logi_l),
bor3(eym != 1L, t > 1L, !logi_l))
expect_equal(or3s(eyn != 9L, m > 9L, !logi_v),
bor3(eyn != 9L, m > 9L, !logi_v))
expect_equal(or3s(eyo != 0L, , ),
bor3(eyo != 0L, , ))
expect_equal(or3s(eyp != 1L, , ),
bor3(eyp != 1L, , ))
expect_equal(or3s(eyq != 9L, , ),
bor3(eyq != 9L, , ))
expect_equal(or3s(eyr != 0L, , s != 0L),
bor3(eyr != 0L, , s != 0L))
expect_equal(or3s(eys != 1L, , c != 1L),
bor3(eys != 1L, , c != 1L))
expect_equal(or3s(eyt != 9L, , a != 9L),
bor3(eyt != 9L, , a != 9L))
expect_equal(or3s(eyu != 0L, p > 0L, ),
bor3(eyu != 0L, p > 0L, ))
expect_equal(or3s(eyv != 1L, t > 1L, ),
bor3(eyv != 1L, t > 1L, ))
expect_equal(or3s(eyw != 9L, b > 9L, ),
bor3(eyw != 9L, b > 9L, ))
expect_equal(or3s(eyx != 0L, o > 0L, m != 0L),
bor3(eyx != 0L, o > 0L, m != 0L))
expect_equal(or3s(eyy != 1L, k > 1L, z != 1L),
bor3(eyy != 1L, k > 1L, z != 1L))
expect_equal(or3s(eyz != 9L, m > 9L, w != 9L),
bor3(eyz != 9L, m > 9L, w != 9L))
expect_equal(or3s(fa != 0L, , ),
bor3(fa != 0L, , ))
expect_equal(or3s(fb != 1L, , ),
bor3(fb != 1L, , ))
expect_equal(or3s(fc != 9L, , ),
bor3(fc != 9L, , ))
expect_equal(or3s(fd != 0L, , a %between% c(-1L, 1L)),
bor3(fd != 0L, , a %between% c(-1L, 1L)))
expect_equal(or3s(fe != 1L, , r %between% c(-1L, 1L)),
bor3(fe != 1L, , r %between% c(-1L, 1L)))
expect_equal(or3s(ff != 9L, , b %between% c(-1L, 1L)),
bor3(ff != 9L, , b %between% c(-1L, 1L)))
expect_equal(or3s(fg != 0L, z > 0L, ),
bor3(fg != 0L, z > 0L, ))
expect_equal(or3s(fh != 1L, u > 1L, ),
bor3(fh != 1L, u > 1L, ))
expect_equal(or3s(fi != 9L, u > 9L, ),
bor3(fi != 9L, u > 9L, ))
expect_equal(or3s(fj != 0L, v > 0L, b %between% c(-1L, 1L)),
bor3(fj != 0L, v > 0L, b %between% c(-1L, 1L)))
expect_equal(or3s(fk != 1L, w > 1L, p %between% c(-1L, 1L)),
bor3(fk != 1L, w > 1L, p %between% c(-1L, 1L)))
expect_equal(or3s(fl != 9L, x > 9L, l %between% c(-1L, 1L)),
bor3(fl != 9L, x > 9L, l %between% c(-1L, 1L)))
expect_equal(or3s(fm != 0L, , ),
bor3(fm != 0L, , ))
expect_equal(or3s(fn != 1L, , ),
bor3(fn != 1L, , ))
expect_equal(or3s(fo != 9L, , ),
bor3(fo != 9L, , ))
expect_equal(or3s(fp != 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fp != 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fq != 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fq != 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fr != 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fr != 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fs != 0L, t > 0L, ),
bor3(fs != 0L, t > 0L, ))
expect_equal(or3s(ft != 1L, d > 1L, ),
bor3(ft != 1L, d > 1L, ))
expect_equal(or3s(fu != 9L, u > 9L, ),
bor3(fu != 9L, u > 9L, ))
expect_equal(or3s(fv != 0L, w > 0L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fv != 0L, w > 0L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fw != 1L, u > 1L, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fw != 1L, u > 1L, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fx != 9L, o > 9L, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fx != 9L, o > 9L, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fy != 0L, , ),
bor3(fy != 0L, , ))
expect_equal(or3s(fz != 1L, , ),
bor3(fz != 1L, , ))
expect_equal(or3s(faa != 9L, , ),
bor3(faa != 9L, , ))
expect_equal(or3s(fab != 0L, , w %in% 1:4),
bor3(fab != 0L, , w %in% 1:4))
expect_equal(or3s(fac != 1L, , b %in% 1:4),
bor3(fac != 1L, , b %in% 1:4))
expect_equal(or3s(fad != 9L, , n %in% 1:4),
bor3(fad != 9L, , n %in% 1:4))
expect_equal(or3s(fae != 0L, c > 0L, ),
bor3(fae != 0L, c > 0L, ))
expect_equal(or3s(faf != 1L, y > 1L, ),
bor3(faf != 1L, y > 1L, ))
expect_equal(or3s(fag != 9L, v > 9L, ),
bor3(fag != 9L, v > 9L, ))
expect_equal(or3s(fah != 0L, w > 0L, e %in% 1:4),
bor3(fah != 0L, w > 0L, e %in% 1:4))
expect_equal(or3s(fai != 1L, r > 1L, h %in% 1:4),
bor3(fai != 1L, r > 1L, h %in% 1:4))
expect_equal(or3s(faj != 9L, u > 9L, r %in% 1:4),
bor3(faj != 9L, u > 9L, r %in% 1:4))
expect_equal(or3s(fak != 0L, , ),
bor3(fak != 0L, , ))
expect_equal(or3s(fal != 1L, , ),
bor3(fal != 1L, , ))
expect_equal(or3s(fam != 9L, , ),
bor3(fam != 9L, , ))
expect_equal(or3s(fan != 0L, , e < 0L),
bor3(fan != 0L, , e < 0L))
expect_equal(or3s(fao != 1L, , p < 1L),
bor3(fao != 1L, , p < 1L))
expect_equal(or3s(fap != 9L, , c < 9L),
bor3(fap != 9L, , c < 9L))
expect_equal(or3s(faq != 0L, h > 0L, ),
bor3(faq != 0L, h > 0L, ))
expect_equal(or3s(far != 1L, c > 1L, ),
bor3(far != 1L, c > 1L, ))
expect_equal(or3s(fas != 9L, c > 9L, ),
bor3(fas != 9L, c > 9L, ))
expect_equal(or3s(fat != 0L, c > 0L, h < 0L),
bor3(fat != 0L, c > 0L, h < 0L))
expect_equal(or3s(fau != 1L, u > 1L, g < 1L),
bor3(fau != 1L, u > 1L, g < 1L))
expect_equal(or3s(fav != 9L, l > 9L, y < 9L),
bor3(fav != 9L, l > 9L, y < 9L))
expect_equal(or3s(faw != 0L, , ),
bor3(faw != 0L, , ))
expect_equal(or3s(fax != 1L, , ),
bor3(fax != 1L, , ))
expect_equal(or3s(fay != 9L, , ),
bor3(fay != 9L, , ))
expect_equal(or3s(faz != 0L, , i <= 0L),
bor3(faz != 0L, , i <= 0L))
expect_equal(or3s(fba != 1L, , w <= 1L),
bor3(fba != 1L, , w <= 1L))
expect_equal(or3s(fbb != 9L, , e <= 9L),
bor3(fbb != 9L, , e <= 9L))
expect_equal(or3s(fbc != 0L, x > 0L, ),
bor3(fbc != 0L, x > 0L, ))
expect_equal(or3s(fbd != 1L, q > 1L, ),
bor3(fbd != 1L, q > 1L, ))
expect_equal(or3s(fbe != 9L, x > 9L, ),
bor3(fbe != 9L, x > 9L, ))
expect_equal(or3s(fbf != 0L, x > 0L, e <= 0L),
bor3(fbf != 0L, x > 0L, e <= 0L))
expect_equal(or3s(fbg != 1L, n > 1L, q <= 1L),
bor3(fbg != 1L, n > 1L, q <= 1L))
expect_equal(or3s(fbh != 9L, l > 9L, i <= 9L),
bor3(fbh != 9L, l > 9L, i <= 9L))
expect_equal(or3s(fbi != 0L, , ),
bor3(fbi != 0L, , ))
expect_equal(or3s(fbj != 1L, , ),
bor3(fbj != 1L, , ))
expect_equal(or3s(fbk != 9L, , ),
bor3(fbk != 9L, , ))
expect_equal(or3s(fbl != 0L, , g == 0L),
bor3(fbl != 0L, , g == 0L))
expect_equal(or3s(fbm != 1L, , y == 1L),
bor3(fbm != 1L, , y == 1L))
expect_equal(or3s(fbn != 9L, , n == 9L),
bor3(fbn != 9L, , n == 9L))
expect_equal(or3s(fbo != 0L, b > 0L, ),
bor3(fbo != 0L, b > 0L, ))
expect_equal(or3s(fbp != 1L, k > 1L, ),
bor3(fbp != 1L, k > 1L, ))
expect_equal(or3s(fbq != 9L, z > 9L, ),
bor3(fbq != 9L, z > 9L, ))
expect_equal(or3s(fbr != 0L, l > 0L, y == 0L),
bor3(fbr != 0L, l > 0L, y == 0L))
expect_equal(or3s(fbs != 1L, m > 1L, b == 1L),
bor3(fbs != 1L, m > 1L, b == 1L))
expect_equal(or3s(fbt != 9L, s > 9L, m == 9L),
bor3(fbt != 9L, s > 9L, m == 9L))
expect_equal(or3s(fbu != 0L, , ),
bor3(fbu != 0L, , ))
expect_equal(or3s(fbv != 1L, , ),
bor3(fbv != 1L, , ))
expect_equal(or3s(fbw != 9L, , ),
bor3(fbw != 9L, , ))
expect_equal(or3s(fbx != 0L, , g > 0L),
bor3(fbx != 0L, , g > 0L))
expect_equal(or3s(fby != 1L, , t > 1L),
bor3(fby != 1L, , t > 1L))
expect_equal(or3s(fbz != 9L, , c > 9L),
bor3(fbz != 9L, , c > 9L))
expect_equal(or3s(fca != 0L, x > 0L, ),
bor3(fca != 0L, x > 0L, ))
expect_equal(or3s(fcb != 1L, i > 1L, ),
bor3(fcb != 1L, i > 1L, ))
expect_equal(or3s(fcc != 9L, d > 9L, ),
bor3(fcc != 9L, d > 9L, ))
expect_equal(or3s(fcd != 0L, j > 0L, y > 0L),
bor3(fcd != 0L, j > 0L, y > 0L))
expect_equal(or3s(fce != 1L, n > 1L, q > 1L),
bor3(fce != 1L, n > 1L, q > 1L))
expect_equal(or3s(fcf != 9L, q > 9L, x > 9L),
bor3(fcf != 9L, q > 9L, x > 9L))
expect_equal(or3s(fcg != 0L, , ),
bor3(fcg != 0L, , ))
expect_equal(or3s(fch != 1L, , ),
bor3(fch != 1L, , ))
expect_equal(or3s(fci != 9L, , ),
bor3(fci != 9L, , ))
expect_equal(or3s(fcj != 0L, , u >= 0L),
bor3(fcj != 0L, , u >= 0L))
expect_equal(or3s(fck != 1L, , z >= 1L),
bor3(fck != 1L, , z >= 1L))
expect_equal(or3s(fcl != 9L, , w >= 9L),
bor3(fcl != 9L, , w >= 9L))
expect_equal(or3s(fcm != 0L, w > 0L, ),
bor3(fcm != 0L, w > 0L, ))
expect_equal(or3s(fcn != 1L, p > 1L, ),
bor3(fcn != 1L, p > 1L, ))
expect_equal(or3s(fco != 9L, d > 9L, ),
bor3(fco != 9L, d > 9L, ))
expect_equal(or3s(fcp != 0L, i > 0L, h >= 0L),
bor3(fcp != 0L, i > 0L, h >= 0L))
expect_equal(or3s(fcq != 1L, s > 1L, w >= 1L),
bor3(fcq != 1L, s > 1L, w >= 1L))
expect_equal(or3s(fcr != 9L, a > 9L, z >= 9L),
bor3(fcr != 9L, a > 9L, z >= 9L))
expect_equal(or3s(fcs != 0L, , ),
bor3(fcs != 0L, , ))
expect_equal(or3s(fct != 1L, , ),
bor3(fct != 1L, , ))
expect_equal(or3s(fcu != 9L, , ),
bor3(fcu != 9L, , ))
expect_equal(or3s(fcv != 0L, , logi_m),
bor3(fcv != 0L, , logi_m))
expect_equal(or3s(fcw != 1L, , logi_u),
bor3(fcw != 1L, , logi_u))
expect_equal(or3s(fcx != 9L, , logi_f),
bor3(fcx != 9L, , logi_f))
expect_equal(or3s(fcy != 0L, a >= 0L, ),
bor3(fcy != 0L, a >= 0L, ))
expect_equal(or3s(fcz != 1L, t >= 1L, ),
bor3(fcz != 1L, t >= 1L, ))
expect_equal(or3s(fda != 9L, c >= 9L, ),
bor3(fda != 9L, c >= 9L, ))
expect_equal(or3s(fdb != 0L, a >= 0L, logi_v),
bor3(fdb != 0L, a >= 0L, logi_v))
expect_equal(or3s(fdc != 1L, d >= 1L, logi_q),
bor3(fdc != 1L, d >= 1L, logi_q))
expect_equal(or3s(fdd != 9L, v >= 9L, logi_y),
bor3(fdd != 9L, v >= 9L, logi_y))
expect_equal(or3s(fde != 0L, , ),
bor3(fde != 0L, , ))
expect_equal(or3s(fdf != 1L, , ),
bor3(fdf != 1L, , ))
expect_equal(or3s(fdg != 9L, , ),
bor3(fdg != 9L, , ))
expect_equal(or3s(fdh != 0L, , !logi_x),
bor3(fdh != 0L, , !logi_x))
expect_equal(or3s(fdi != 1L, , !logi_e),
bor3(fdi != 1L, , !logi_e))
expect_equal(or3s(fdj != 9L, , !logi_j),
bor3(fdj != 9L, , !logi_j))
expect_equal(or3s(fdk != 0L, i >= 0L, ),
bor3(fdk != 0L, i >= 0L, ))
expect_equal(or3s(fdl != 1L, o >= 1L, ),
bor3(fdl != 1L, o >= 1L, ))
expect_equal(or3s(fdm != 9L, q >= 9L, ),
bor3(fdm != 9L, q >= 9L, ))
expect_equal(or3s(fdn != 0L, c >= 0L, !logi_a),
bor3(fdn != 0L, c >= 0L, !logi_a))
expect_equal(or3s(fdo != 1L, u >= 1L, !logi_s),
bor3(fdo != 1L, u >= 1L, !logi_s))
expect_equal(or3s(fdp != 9L, d >= 9L, !logi_i),
bor3(fdp != 9L, d >= 9L, !logi_i))
expect_equal(or3s(fdq != 0L, , ),
bor3(fdq != 0L, , ))
expect_equal(or3s(fdr != 1L, , ),
bor3(fdr != 1L, , ))
expect_equal(or3s(fds != 9L, , ),
bor3(fds != 9L, , ))
expect_equal(or3s(fdt != 0L, , n != 0L),
bor3(fdt != 0L, , n != 0L))
expect_equal(or3s(fdu != 1L, , v != 1L),
bor3(fdu != 1L, , v != 1L))
expect_equal(or3s(fdv != 9L, , p != 9L),
bor3(fdv != 9L, , p != 9L))
expect_equal(or3s(fdw != 0L, h >= 0L, ),
bor3(fdw != 0L, h >= 0L, ))
expect_equal(or3s(fdx != 1L, x >= 1L, ),
bor3(fdx != 1L, x >= 1L, ))
expect_equal(or3s(fdy != 9L, t >= 9L, ),
bor3(fdy != 9L, t >= 9L, ))
expect_equal(or3s(fdz != 0L, k >= 0L, h != 0L),
bor3(fdz != 0L, k >= 0L, h != 0L))
expect_equal(or3s(fea != 1L, b >= 1L, z != 1L),
bor3(fea != 1L, b >= 1L, z != 1L))
expect_equal(or3s(feb != 9L, k >= 9L, t != 9L),
bor3(feb != 9L, k >= 9L, t != 9L))
expect_equal(or3s(fec != 0L, , ),
bor3(fec != 0L, , ))
expect_equal(or3s(fed != 1L, , ),
bor3(fed != 1L, , ))
expect_equal(or3s(fee != 9L, , ),
bor3(fee != 9L, , ))
expect_equal(or3s(fef != 0L, , e %between% c(-1L, 1L)),
bor3(fef != 0L, , e %between% c(-1L, 1L)))
expect_equal(or3s(feg != 1L, , s %between% c(-1L, 1L)),
bor3(feg != 1L, , s %between% c(-1L, 1L)))
expect_equal(or3s(feh != 9L, , a %between% c(-1L, 1L)),
bor3(feh != 9L, , a %between% c(-1L, 1L)))
expect_equal(or3s(fei != 0L, a >= 0L, ),
bor3(fei != 0L, a >= 0L, ))
expect_equal(or3s(fej != 1L, z >= 1L, ),
bor3(fej != 1L, z >= 1L, ))
expect_equal(or3s(fek != 9L, u >= 9L, ),
bor3(fek != 9L, u >= 9L, ))
expect_equal(or3s(fel != 0L, z >= 0L, i %between% c(-1L, 1L)),
bor3(fel != 0L, z >= 0L, i %between% c(-1L, 1L)))
expect_equal(or3s(fem != 1L, m >= 1L, i %between% c(-1L, 1L)),
bor3(fem != 1L, m >= 1L, i %between% c(-1L, 1L)))
expect_equal(or3s(fen != 9L, d >= 9L, f %between% c(-1L, 1L)),
bor3(fen != 9L, d >= 9L, f %between% c(-1L, 1L)))
expect_equal(or3s(feo != 0L, , ),
bor3(feo != 0L, , ))
expect_equal(or3s(fep != 1L, , ),
bor3(fep != 1L, , ))
expect_equal(or3s(feq != 9L, , ),
bor3(feq != 9L, , ))
expect_equal(or3s(fer != 0L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fer != 0L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fes != 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fes != 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fet != 9L, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fet != 9L, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(feu != 0L, q >= 0L, ),
bor3(feu != 0L, q >= 0L, ))
expect_equal(or3s(fev != 1L, k >= 1L, ),
bor3(fev != 1L, k >= 1L, ))
expect_equal(or3s(few != 9L, z >= 9L, ),
bor3(few != 9L, z >= 9L, ))
expect_equal(or3s(fex != 0L, m >= 0L, l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fex != 0L, m >= 0L, l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fey != 1L, q >= 1L, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fey != 1L, q >= 1L, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fez != 9L, u >= 9L, l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fez != 9L, u >= 9L, l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ffa != 0L, , ),
bor3(ffa != 0L, , ))
expect_equal(or3s(ffb != 1L, , ),
bor3(ffb != 1L, , ))
expect_equal(or3s(ffc != 9L, , ),
bor3(ffc != 9L, , ))
expect_equal(or3s(ffd != 0L, , n %in% 1:4),
bor3(ffd != 0L, , n %in% 1:4))
expect_equal(or3s(ffe != 1L, , l %in% 1:4),
bor3(ffe != 1L, , l %in% 1:4))
expect_equal(or3s(fff != 9L, , w %in% 1:4),
bor3(fff != 9L, , w %in% 1:4))
expect_equal(or3s(ffg != 0L, m >= 0L, ),
bor3(ffg != 0L, m >= 0L, ))
expect_equal(or3s(ffh != 1L, t >= 1L, ),
bor3(ffh != 1L, t >= 1L, ))
expect_equal(or3s(ffi != 9L, m >= 9L, ),
bor3(ffi != 9L, m >= 9L, ))
expect_equal(or3s(ffj != 0L, v >= 0L, x %in% 1:4),
bor3(ffj != 0L, v >= 0L, x %in% 1:4))
expect_equal(or3s(ffk != 1L, w >= 1L, x %in% 1:4),
bor3(ffk != 1L, w >= 1L, x %in% 1:4))
expect_equal(or3s(ffl != 9L, n >= 9L, h %in% 1:4),
bor3(ffl != 9L, n >= 9L, h %in% 1:4))
expect_equal(or3s(ffm != 0L, , ),
bor3(ffm != 0L, , ))
expect_equal(or3s(ffn != 1L, , ),
bor3(ffn != 1L, , ))
expect_equal(or3s(ffo != 9L, , ),
bor3(ffo != 9L, , ))
expect_equal(or3s(ffp != 0L, , c < 0L),
bor3(ffp != 0L, , c < 0L))
expect_equal(or3s(ffq != 1L, , l < 1L),
bor3(ffq != 1L, , l < 1L))
expect_equal(or3s(ffr != 9L, , m < 9L),
bor3(ffr != 9L, , m < 9L))
expect_equal(or3s(ffs != 0L, l >= 0L, ),
bor3(ffs != 0L, l >= 0L, ))
expect_equal(or3s(fft != 1L, v >= 1L, ),
bor3(fft != 1L, v >= 1L, ))
expect_equal(or3s(ffu != 9L, x >= 9L, ),
bor3(ffu != 9L, x >= 9L, ))
expect_equal(or3s(ffv != 0L, v >= 0L, h < 0L),
bor3(ffv != 0L, v >= 0L, h < 0L))
expect_equal(or3s(ffw != 1L, h >= 1L, d < 1L),
bor3(ffw != 1L, h >= 1L, d < 1L))
expect_equal(or3s(ffx != 9L, w >= 9L, o < 9L),
bor3(ffx != 9L, w >= 9L, o < 9L))
expect_equal(or3s(ffy != 0L, , ),
bor3(ffy != 0L, , ))
expect_equal(or3s(ffz != 1L, , ),
bor3(ffz != 1L, , ))
expect_equal(or3s(fga != 9L, , ),
bor3(fga != 9L, , ))
expect_equal(or3s(fgb != 0L, , d <= 0L),
bor3(fgb != 0L, , d <= 0L))
expect_equal(or3s(fgc != 1L, , x <= 1L),
bor3(fgc != 1L, , x <= 1L))
expect_equal(or3s(fgd != 9L, , l <= 9L),
bor3(fgd != 9L, , l <= 9L))
expect_equal(or3s(fge != 0L, w >= 0L, ),
bor3(fge != 0L, w >= 0L, ))
expect_equal(or3s(fgf != 1L, k >= 1L, ),
bor3(fgf != 1L, k >= 1L, ))
expect_equal(or3s(fgg != 9L, v >= 9L, ),
bor3(fgg != 9L, v >= 9L, ))
expect_equal(or3s(fgh != 0L, y >= 0L, o <= 0L),
bor3(fgh != 0L, y >= 0L, o <= 0L))
expect_equal(or3s(fgi != 1L, t >= 1L, z <= 1L),
bor3(fgi != 1L, t >= 1L, z <= 1L))
expect_equal(or3s(fgj != 9L, p >= 9L, y <= 9L),
bor3(fgj != 9L, p >= 9L, y <= 9L))
expect_equal(or3s(fgk != 0L, , ),
bor3(fgk != 0L, , ))
expect_equal(or3s(fgl != 1L, , ),
bor3(fgl != 1L, , ))
expect_equal(or3s(fgm != 9L, , ),
bor3(fgm != 9L, , ))
expect_equal(or3s(fgn != 0L, , w == 0L),
bor3(fgn != 0L, , w == 0L))
expect_equal(or3s(fgo != 1L, , f == 1L),
bor3(fgo != 1L, , f == 1L))
expect_equal(or3s(fgp != 9L, , c == 9L),
bor3(fgp != 9L, , c == 9L))
expect_equal(or3s(fgq != 0L, n >= 0L, ),
bor3(fgq != 0L, n >= 0L, ))
expect_equal(or3s(fgr != 1L, v >= 1L, ),
bor3(fgr != 1L, v >= 1L, ))
expect_equal(or3s(fgs != 9L, y >= 9L, ),
bor3(fgs != 9L, y >= 9L, ))
expect_equal(or3s(fgt != 0L, k >= 0L, n == 0L),
bor3(fgt != 0L, k >= 0L, n == 0L))
expect_equal(or3s(fgu != 1L, u >= 1L, e == 1L),
bor3(fgu != 1L, u >= 1L, e == 1L))
expect_equal(or3s(fgv != 9L, d >= 9L, n == 9L),
bor3(fgv != 9L, d >= 9L, n == 9L))
expect_equal(or3s(fgw != 0L, , ),
bor3(fgw != 0L, , ))
expect_equal(or3s(fgx != 1L, , ),
bor3(fgx != 1L, , ))
expect_equal(or3s(fgy != 9L, , ),
bor3(fgy != 9L, , ))
expect_equal(or3s(fgz != 0L, , v > 0L),
bor3(fgz != 0L, , v > 0L))
expect_equal(or3s(fha != 1L, , m > 1L),
bor3(fha != 1L, , m > 1L))
expect_equal(or3s(fhb != 9L, , b > 9L),
bor3(fhb != 9L, , b > 9L))
expect_equal(or3s(fhc != 0L, y >= 0L, ),
bor3(fhc != 0L, y >= 0L, ))
expect_equal(or3s(fhd != 1L, k >= 1L, ),
bor3(fhd != 1L, k >= 1L, ))
expect_equal(or3s(fhe != 9L, t >= 9L, ),
bor3(fhe != 9L, t >= 9L, ))
expect_equal(or3s(fhf != 0L, n >= 0L, t > 0L),
bor3(fhf != 0L, n >= 0L, t > 0L))
expect_equal(or3s(fhg != 1L, g >= 1L, s > 1L),
bor3(fhg != 1L, g >= 1L, s > 1L))
expect_equal(or3s(fhh != 9L, f >= 9L, i > 9L),
bor3(fhh != 9L, f >= 9L, i > 9L))
expect_equal(or3s(fhi != 0L, , ),
bor3(fhi != 0L, , ))
expect_equal(or3s(fhj != 1L, , ),
bor3(fhj != 1L, , ))
expect_equal(or3s(fhk != 9L, , ),
bor3(fhk != 9L, , ))
expect_equal(or3s(fhl != 0L, , h >= 0L),
bor3(fhl != 0L, , h >= 0L))
expect_equal(or3s(fhm != 1L, , n >= 1L),
bor3(fhm != 1L, , n >= 1L))
expect_equal(or3s(fhn != 9L, , n >= 9L),
bor3(fhn != 9L, , n >= 9L))
expect_equal(or3s(fho != 0L, p >= 0L, ),
bor3(fho != 0L, p >= 0L, ))
expect_equal(or3s(fhp != 1L, b >= 1L, ),
bor3(fhp != 1L, b >= 1L, ))
expect_equal(or3s(fhq != 9L, b >= 9L, ),
bor3(fhq != 9L, b >= 9L, ))
expect_equal(or3s(fhr != 0L, e >= 0L, c >= 0L),
bor3(fhr != 0L, e >= 0L, c >= 0L))
expect_equal(or3s(fhs != 1L, t >= 1L, k >= 1L),
bor3(fhs != 1L, t >= 1L, k >= 1L))
expect_equal(or3s(fht != 9L, t >= 9L, g >= 9L),
bor3(fht != 9L, t >= 9L, g >= 9L))
expect_equal(or3s(fhu %between% c(-1L, 1L), , ),
bor3(fhu %between% c(-1L, 1L), , ))
expect_equal(or3s(fhv %between% c(-1L, 1L), , ),
bor3(fhv %between% c(-1L, 1L), , ))
expect_equal(or3s(fhw %between% c(-1L, 1L), , ),
bor3(fhw %between% c(-1L, 1L), , ))
expect_equal(or3s(fhx %between% c(-1L, 1L), , logi_m),
bor3(fhx %between% c(-1L, 1L), , logi_m))
expect_equal(or3s(fhy %between% c(-1L, 1L), , logi_e),
bor3(fhy %between% c(-1L, 1L), , logi_e))
expect_equal(or3s(fhz %between% c(-1L, 1L), , logi_y),
bor3(fhz %between% c(-1L, 1L), , logi_y))
expect_equal(or3s(fia %between% c(-1L, 1L), logi_k, ),
bor3(fia %between% c(-1L, 1L), logi_k, ))
expect_equal(or3s(fib %between% c(-1L, 1L), logi_e, ),
bor3(fib %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(fic %between% c(-1L, 1L), logi_m, ),
bor3(fic %between% c(-1L, 1L), logi_m, ))
expect_equal(or3s(fid %between% c(-1L, 1L), logi_n, logi_f),
bor3(fid %between% c(-1L, 1L), logi_n, logi_f))
expect_equal(or3s(fie %between% c(-1L, 1L), logi_e, logi_k),
bor3(fie %between% c(-1L, 1L), logi_e, logi_k))
expect_equal(or3s(fif %between% c(-1L, 1L), logi_n, logi_m),
bor3(fif %between% c(-1L, 1L), logi_n, logi_m))
expect_equal(or3s(fig %between% c(-1L, 1L), , ),
bor3(fig %between% c(-1L, 1L), , ))
expect_equal(or3s(fih %between% c(-1L, 1L), , ),
bor3(fih %between% c(-1L, 1L), , ))
expect_equal(or3s(fii %between% c(-1L, 1L), , ),
bor3(fii %between% c(-1L, 1L), , ))
expect_equal(or3s(fij %between% c(-1L, 1L), , !logi_c),
bor3(fij %between% c(-1L, 1L), , !logi_c))
expect_equal(or3s(fik %between% c(-1L, 1L), , !logi_i),
bor3(fik %between% c(-1L, 1L), , !logi_i))
expect_equal(or3s(fil %between% c(-1L, 1L), , !logi_n),
bor3(fil %between% c(-1L, 1L), , !logi_n))
expect_equal(or3s(fim %between% c(-1L, 1L), logi_n, ),
bor3(fim %between% c(-1L, 1L), logi_n, ))
expect_equal(or3s(fin %between% c(-1L, 1L), logi_g, ),
bor3(fin %between% c(-1L, 1L), logi_g, ))
expect_equal(or3s(fio %between% c(-1L, 1L), logi_r, ),
bor3(fio %between% c(-1L, 1L), logi_r, ))
expect_equal(or3s(fip %between% c(-1L, 1L), logi_a, !logi_n),
bor3(fip %between% c(-1L, 1L), logi_a, !logi_n))
expect_equal(or3s(fiq %between% c(-1L, 1L), logi_g, !logi_a),
bor3(fiq %between% c(-1L, 1L), logi_g, !logi_a))
expect_equal(or3s(fir %between% c(-1L, 1L), logi_t, !logi_h),
bor3(fir %between% c(-1L, 1L), logi_t, !logi_h))
expect_equal(or3s(fis %between% c(-1L, 1L), , ),
bor3(fis %between% c(-1L, 1L), , ))
expect_equal(or3s(fit %between% c(-1L, 1L), , ),
bor3(fit %between% c(-1L, 1L), , ))
expect_equal(or3s(fiu %between% c(-1L, 1L), , ),
bor3(fiu %between% c(-1L, 1L), , ))
expect_equal(or3s(fiv %between% c(-1L, 1L), , w != 0L),
bor3(fiv %between% c(-1L, 1L), , w != 0L))
expect_equal(or3s(fiw %between% c(-1L, 1L), , t != 1L),
bor3(fiw %between% c(-1L, 1L), , t != 1L))
expect_equal(or3s(fix %between% c(-1L, 1L), , u != 9L),
bor3(fix %between% c(-1L, 1L), , u != 9L))
expect_equal(or3s(fiy %between% c(-1L, 1L), logi_y, ),
bor3(fiy %between% c(-1L, 1L), logi_y, ))
expect_equal(or3s(fiz %between% c(-1L, 1L), logi_q, ),
bor3(fiz %between% c(-1L, 1L), logi_q, ))
expect_equal(or3s(fja %between% c(-1L, 1L), logi_a, ),
bor3(fja %between% c(-1L, 1L), logi_a, ))
expect_equal(or3s(fjb %between% c(-1L, 1L), logi_l, u != 0L),
bor3(fjb %between% c(-1L, 1L), logi_l, u != 0L))
expect_equal(or3s(fjc %between% c(-1L, 1L), logi_b, g != 1L),
bor3(fjc %between% c(-1L, 1L), logi_b, g != 1L))
expect_equal(or3s(fjd %between% c(-1L, 1L), logi_e, v != 9L),
bor3(fjd %between% c(-1L, 1L), logi_e, v != 9L))
expect_equal(or3s(fje %between% c(-1L, 1L), , ),
bor3(fje %between% c(-1L, 1L), , ))
expect_equal(or3s(fjf %between% c(-1L, 1L), , ),
bor3(fjf %between% c(-1L, 1L), , ))
expect_equal(or3s(fjg %between% c(-1L, 1L), , ),
bor3(fjg %between% c(-1L, 1L), , ))
expect_equal(or3s(fjh %between% c(-1L, 1L), , x %between% c(-1L, 1L)),
bor3(fjh %between% c(-1L, 1L), , x %between% c(-1L, 1L)))
expect_equal(or3s(fji %between% c(-1L, 1L), , c %between% c(-1L, 1L)),
bor3(fji %between% c(-1L, 1L), , c %between% c(-1L, 1L)))
expect_equal(or3s(fjj %between% c(-1L, 1L), , u %between% c(-1L, 1L)),
bor3(fjj %between% c(-1L, 1L), , u %between% c(-1L, 1L)))
expect_equal(or3s(fjk %between% c(-1L, 1L), logi_t, ),
bor3(fjk %between% c(-1L, 1L), logi_t, ))
expect_equal(or3s(fjl %between% c(-1L, 1L), logi_e, ),
bor3(fjl %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(fjm %between% c(-1L, 1L), logi_r, ),
bor3(fjm %between% c(-1L, 1L), logi_r, ))
expect_equal(or3s(fjn %between% c(-1L, 1L), logi_e, h %between% c(-1L, 1L)),
bor3(fjn %between% c(-1L, 1L), logi_e, h %between% c(-1L, 1L)))
expect_equal(or3s(fjo %between% c(-1L, 1L), logi_m, y %between% c(-1L, 1L)),
bor3(fjo %between% c(-1L, 1L), logi_m, y %between% c(-1L, 1L)))
expect_equal(or3s(fjp %between% c(-1L, 1L), logi_g, a %between% c(-1L, 1L)),
bor3(fjp %between% c(-1L, 1L), logi_g, a %between% c(-1L, 1L)))
expect_equal(or3s(fjq %between% c(-1L, 1L), , ),
bor3(fjq %between% c(-1L, 1L), , ))
expect_equal(or3s(fjr %between% c(-1L, 1L), , ),
bor3(fjr %between% c(-1L, 1L), , ))
expect_equal(or3s(fjs %between% c(-1L, 1L), , ),
bor3(fjs %between% c(-1L, 1L), , ))
expect_equal(or3s(fjt %between% c(-1L, 1L), , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fjt %between% c(-1L, 1L), , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fju %between% c(-1L, 1L), , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fju %between% c(-1L, 1L), , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fjv %between% c(-1L, 1L), , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fjv %between% c(-1L, 1L), , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fjw %between% c(-1L, 1L), logi_k, ),
bor3(fjw %between% c(-1L, 1L), logi_k, ))
expect_equal(or3s(fjx %between% c(-1L, 1L), logi_d, ),
bor3(fjx %between% c(-1L, 1L), logi_d, ))
expect_equal(or3s(fjy %between% c(-1L, 1L), logi_x, ),
bor3(fjy %between% c(-1L, 1L), logi_x, ))
expect_equal(or3s(fjz %between% c(-1L, 1L), logi_c, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fjz %between% c(-1L, 1L), logi_c, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fka %between% c(-1L, 1L), logi_l, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fka %between% c(-1L, 1L), logi_l, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fkb %between% c(-1L, 1L), logi_q, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fkb %between% c(-1L, 1L), logi_q, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fkc %between% c(-1L, 1L), , ),
bor3(fkc %between% c(-1L, 1L), , ))
expect_equal(or3s(fkd %between% c(-1L, 1L), , ),
bor3(fkd %between% c(-1L, 1L), , ))
expect_equal(or3s(fke %between% c(-1L, 1L), , ),
bor3(fke %between% c(-1L, 1L), , ))
expect_equal(or3s(fkf %between% c(-1L, 1L), , h %in% 1:4),
bor3(fkf %between% c(-1L, 1L), , h %in% 1:4))
expect_equal(or3s(fkg %between% c(-1L, 1L), , v %in% 1:4),
bor3(fkg %between% c(-1L, 1L), , v %in% 1:4))
expect_equal(or3s(fkh %between% c(-1L, 1L), , w %in% 1:4),
bor3(fkh %between% c(-1L, 1L), , w %in% 1:4))
expect_equal(or3s(fki %between% c(-1L, 1L), logi_e, ),
bor3(fki %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(fkj %between% c(-1L, 1L), logi_x, ),
bor3(fkj %between% c(-1L, 1L), logi_x, ))
expect_equal(or3s(fkk %between% c(-1L, 1L), logi_s, ),
bor3(fkk %between% c(-1L, 1L), logi_s, ))
expect_equal(or3s(fkl %between% c(-1L, 1L), logi_w, a %in% 1:4),
bor3(fkl %between% c(-1L, 1L), logi_w, a %in% 1:4))
expect_equal(or3s(fkm %between% c(-1L, 1L), logi_b, r %in% 1:4),
bor3(fkm %between% c(-1L, 1L), logi_b, r %in% 1:4))
expect_equal(or3s(fkn %between% c(-1L, 1L), logi_k, a %in% 1:4),
bor3(fkn %between% c(-1L, 1L), logi_k, a %in% 1:4))
expect_equal(or3s(fko %between% c(-1L, 1L), , ),
bor3(fko %between% c(-1L, 1L), , ))
expect_equal(or3s(fkp %between% c(-1L, 1L), , ),
bor3(fkp %between% c(-1L, 1L), , ))
expect_equal(or3s(fkq %between% c(-1L, 1L), , ),
bor3(fkq %between% c(-1L, 1L), , ))
expect_equal(or3s(fkr %between% c(-1L, 1L), , e < 0L),
bor3(fkr %between% c(-1L, 1L), , e < 0L))
expect_equal(or3s(fks %between% c(-1L, 1L), , n < 1L),
bor3(fks %between% c(-1L, 1L), , n < 1L))
expect_equal(or3s(fkt %between% c(-1L, 1L), , a < 9L),
bor3(fkt %between% c(-1L, 1L), , a < 9L))
expect_equal(or3s(fku %between% c(-1L, 1L), logi_e, ),
bor3(fku %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(fkv %between% c(-1L, 1L), logi_i, ),
bor3(fkv %between% c(-1L, 1L), logi_i, ))
expect_equal(or3s(fkw %between% c(-1L, 1L), logi_o, ),
bor3(fkw %between% c(-1L, 1L), logi_o, ))
expect_equal(or3s(fkx %between% c(-1L, 1L), logi_e, m < 0L),
bor3(fkx %between% c(-1L, 1L), logi_e, m < 0L))
expect_equal(or3s(fky %between% c(-1L, 1L), logi_d, d < 1L),
bor3(fky %between% c(-1L, 1L), logi_d, d < 1L))
expect_equal(or3s(fkz %between% c(-1L, 1L), logi_u, a < 9L),
bor3(fkz %between% c(-1L, 1L), logi_u, a < 9L))
expect_equal(or3s(fla %between% c(-1L, 1L), , ),
bor3(fla %between% c(-1L, 1L), , ))
expect_equal(or3s(flb %between% c(-1L, 1L), , ),
bor3(flb %between% c(-1L, 1L), , ))
expect_equal(or3s(flc %between% c(-1L, 1L), , ),
bor3(flc %between% c(-1L, 1L), , ))
expect_equal(or3s(fld %between% c(-1L, 1L), , s <= 0L),
bor3(fld %between% c(-1L, 1L), , s <= 0L))
expect_equal(or3s(fle %between% c(-1L, 1L), , w <= 1L),
bor3(fle %between% c(-1L, 1L), , w <= 1L))
expect_equal(or3s(flf %between% c(-1L, 1L), , f <= 9L),
bor3(flf %between% c(-1L, 1L), , f <= 9L))
expect_equal(or3s(flg %between% c(-1L, 1L), logi_g, ),
bor3(flg %between% c(-1L, 1L), logi_g, ))
expect_equal(or3s(flh %between% c(-1L, 1L), logi_t, ),
bor3(flh %between% c(-1L, 1L), logi_t, ))
expect_equal(or3s(fli %between% c(-1L, 1L), logi_e, ),
bor3(fli %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(flj %between% c(-1L, 1L), logi_o, s <= 0L),
bor3(flj %between% c(-1L, 1L), logi_o, s <= 0L))
expect_equal(or3s(flk %between% c(-1L, 1L), logi_n, c <= 1L),
bor3(flk %between% c(-1L, 1L), logi_n, c <= 1L))
expect_equal(or3s(fll %between% c(-1L, 1L), logi_n, c <= 9L),
bor3(fll %between% c(-1L, 1L), logi_n, c <= 9L))
expect_equal(or3s(flm %between% c(-1L, 1L), , ),
bor3(flm %between% c(-1L, 1L), , ))
expect_equal(or3s(fln %between% c(-1L, 1L), , ),
bor3(fln %between% c(-1L, 1L), , ))
expect_equal(or3s(flo %between% c(-1L, 1L), , ),
bor3(flo %between% c(-1L, 1L), , ))
expect_equal(or3s(flp %between% c(-1L, 1L), , a == 0L),
bor3(flp %between% c(-1L, 1L), , a == 0L))
expect_equal(or3s(flq %between% c(-1L, 1L), , p == 1L),
bor3(flq %between% c(-1L, 1L), , p == 1L))
expect_equal(or3s(flr %between% c(-1L, 1L), , k == 9L),
bor3(flr %between% c(-1L, 1L), , k == 9L))
expect_equal(or3s(fls %between% c(-1L, 1L), logi_n, ),
bor3(fls %between% c(-1L, 1L), logi_n, ))
expect_equal(or3s(flt %between% c(-1L, 1L), logi_e, ),
bor3(flt %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(flu %between% c(-1L, 1L), logi_s, ),
bor3(flu %between% c(-1L, 1L), logi_s, ))
expect_equal(or3s(flv %between% c(-1L, 1L), logi_d, f == 0L),
bor3(flv %between% c(-1L, 1L), logi_d, f == 0L))
expect_equal(or3s(flw %between% c(-1L, 1L), logi_a, g == 1L),
bor3(flw %between% c(-1L, 1L), logi_a, g == 1L))
expect_equal(or3s(flx %between% c(-1L, 1L), logi_b, q == 9L),
bor3(flx %between% c(-1L, 1L), logi_b, q == 9L))
expect_equal(or3s(fly %between% c(-1L, 1L), , ),
bor3(fly %between% c(-1L, 1L), , ))
expect_equal(or3s(flz %between% c(-1L, 1L), , ),
bor3(flz %between% c(-1L, 1L), , ))
expect_equal(or3s(fma %between% c(-1L, 1L), , ),
bor3(fma %between% c(-1L, 1L), , ))
expect_equal(or3s(fmb %between% c(-1L, 1L), , p > 0L),
bor3(fmb %between% c(-1L, 1L), , p > 0L))
expect_equal(or3s(fmc %between% c(-1L, 1L), , y > 1L),
bor3(fmc %between% c(-1L, 1L), , y > 1L))
expect_equal(or3s(fmd %between% c(-1L, 1L), , u > 9L),
bor3(fmd %between% c(-1L, 1L), , u > 9L))
expect_equal(or3s(fme %between% c(-1L, 1L), logi_c, ),
bor3(fme %between% c(-1L, 1L), logi_c, ))
expect_equal(or3s(fmf %between% c(-1L, 1L), logi_e, ),
bor3(fmf %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(fmg %between% c(-1L, 1L), logi_k, ),
bor3(fmg %between% c(-1L, 1L), logi_k, ))
expect_equal(or3s(fmh %between% c(-1L, 1L), logi_k, n > 0L),
bor3(fmh %between% c(-1L, 1L), logi_k, n > 0L))
expect_equal(or3s(fmi %between% c(-1L, 1L), logi_g, q > 1L),
bor3(fmi %between% c(-1L, 1L), logi_g, q > 1L))
expect_equal(or3s(fmj %between% c(-1L, 1L), logi_t, r > 9L),
bor3(fmj %between% c(-1L, 1L), logi_t, r > 9L))
expect_equal(or3s(fmk %between% c(-1L, 1L), , ),
bor3(fmk %between% c(-1L, 1L), , ))
expect_equal(or3s(fml %between% c(-1L, 1L), , ),
bor3(fml %between% c(-1L, 1L), , ))
expect_equal(or3s(fmm %between% c(-1L, 1L), , ),
bor3(fmm %between% c(-1L, 1L), , ))
expect_equal(or3s(fmn %between% c(-1L, 1L), , b >= 0L),
bor3(fmn %between% c(-1L, 1L), , b >= 0L))
expect_equal(or3s(fmo %between% c(-1L, 1L), , l >= 1L),
bor3(fmo %between% c(-1L, 1L), , l >= 1L))
expect_equal(or3s(fmp %between% c(-1L, 1L), , v >= 9L),
bor3(fmp %between% c(-1L, 1L), , v >= 9L))
expect_equal(or3s(fmq %between% c(-1L, 1L), logi_e, ),
bor3(fmq %between% c(-1L, 1L), logi_e, ))
expect_equal(or3s(fmr %between% c(-1L, 1L), logi_h, ),
bor3(fmr %between% c(-1L, 1L), logi_h, ))
expect_equal(or3s(fms %between% c(-1L, 1L), logi_v, ),
bor3(fms %between% c(-1L, 1L), logi_v, ))
expect_equal(or3s(fmt %between% c(-1L, 1L), logi_u, b >= 0L),
bor3(fmt %between% c(-1L, 1L), logi_u, b >= 0L))
expect_equal(or3s(fmu %between% c(-1L, 1L), logi_w, v >= 1L),
bor3(fmu %between% c(-1L, 1L), logi_w, v >= 1L))
expect_equal(or3s(fmv %between% c(-1L, 1L), logi_d, l >= 9L),
bor3(fmv %between% c(-1L, 1L), logi_d, l >= 9L))
expect_equal(or3s(fmw %between% c(-1L, 1L), , ),
bor3(fmw %between% c(-1L, 1L), , ))
expect_equal(or3s(fmx %between% c(-1L, 1L), , ),
bor3(fmx %between% c(-1L, 1L), , ))
expect_equal(or3s(fmy %between% c(-1L, 1L), , ),
bor3(fmy %between% c(-1L, 1L), , ))
expect_equal(or3s(fmz %between% c(-1L, 1L), , logi_w),
bor3(fmz %between% c(-1L, 1L), , logi_w))
expect_equal(or3s(fna %between% c(-1L, 1L), , logi_w),
bor3(fna %between% c(-1L, 1L), , logi_w))
expect_equal(or3s(fnb %between% c(-1L, 1L), , logi_f),
bor3(fnb %between% c(-1L, 1L), , logi_f))
expect_equal(or3s(fnc %between% c(-1L, 1L), !logi_m, ),
bor3(fnc %between% c(-1L, 1L), !logi_m, ))
expect_equal(or3s(fnd %between% c(-1L, 1L), !logi_z, ),
bor3(fnd %between% c(-1L, 1L), !logi_z, ))
expect_equal(or3s(fne %between% c(-1L, 1L), !logi_s, ),
bor3(fne %between% c(-1L, 1L), !logi_s, ))
expect_equal(or3s(fnf %between% c(-1L, 1L), !logi_r, logi_q),
bor3(fnf %between% c(-1L, 1L), !logi_r, logi_q))
expect_equal(or3s(fng %between% c(-1L, 1L), !logi_d, logi_y),
bor3(fng %between% c(-1L, 1L), !logi_d, logi_y))
expect_equal(or3s(fnh %between% c(-1L, 1L), !logi_f, logi_b),
bor3(fnh %between% c(-1L, 1L), !logi_f, logi_b))
expect_equal(or3s(fni %between% c(-1L, 1L), , ),
bor3(fni %between% c(-1L, 1L), , ))
expect_equal(or3s(fnj %between% c(-1L, 1L), , ),
bor3(fnj %between% c(-1L, 1L), , ))
expect_equal(or3s(fnk %between% c(-1L, 1L), , ),
bor3(fnk %between% c(-1L, 1L), , ))
expect_equal(or3s(fnl %between% c(-1L, 1L), , !logi_j),
bor3(fnl %between% c(-1L, 1L), , !logi_j))
expect_equal(or3s(fnm %between% c(-1L, 1L), , !logi_b),
bor3(fnm %between% c(-1L, 1L), , !logi_b))
expect_equal(or3s(fnn %between% c(-1L, 1L), , !logi_f),
bor3(fnn %between% c(-1L, 1L), , !logi_f))
expect_equal(or3s(fno %between% c(-1L, 1L), !logi_n, ),
bor3(fno %between% c(-1L, 1L), !logi_n, ))
expect_equal(or3s(fnp %between% c(-1L, 1L), !logi_e, ),
bor3(fnp %between% c(-1L, 1L), !logi_e, ))
expect_equal(or3s(fnq %between% c(-1L, 1L), !logi_u, ),
bor3(fnq %between% c(-1L, 1L), !logi_u, ))
expect_equal(or3s(fnr %between% c(-1L, 1L), !logi_x, !logi_p),
bor3(fnr %between% c(-1L, 1L), !logi_x, !logi_p))
expect_equal(or3s(fns %between% c(-1L, 1L), !logi_z, !logi_n),
bor3(fns %between% c(-1L, 1L), !logi_z, !logi_n))
expect_equal(or3s(fnt %between% c(-1L, 1L), !logi_m, !logi_l),
bor3(fnt %between% c(-1L, 1L), !logi_m, !logi_l))
expect_equal(or3s(fnu %between% c(-1L, 1L), , ),
bor3(fnu %between% c(-1L, 1L), , ))
expect_equal(or3s(fnv %between% c(-1L, 1L), , ),
bor3(fnv %between% c(-1L, 1L), , ))
expect_equal(or3s(fnw %between% c(-1L, 1L), , ),
bor3(fnw %between% c(-1L, 1L), , ))
expect_equal(or3s(fnx %between% c(-1L, 1L), , b != 0L),
bor3(fnx %between% c(-1L, 1L), , b != 0L))
expect_equal(or3s(fny %between% c(-1L, 1L), , y != 1L),
bor3(fny %between% c(-1L, 1L), , y != 1L))
expect_equal(or3s(fnz %between% c(-1L, 1L), , s != 9L),
bor3(fnz %between% c(-1L, 1L), , s != 9L))
expect_equal(or3s(foa %between% c(-1L, 1L), !logi_j, ),
bor3(foa %between% c(-1L, 1L), !logi_j, ))
expect_equal(or3s(fob %between% c(-1L, 1L), !logi_m, ),
bor3(fob %between% c(-1L, 1L), !logi_m, ))
expect_equal(or3s(foc %between% c(-1L, 1L), !logi_y, ),
bor3(foc %between% c(-1L, 1L), !logi_y, ))
expect_equal(or3s(fod %between% c(-1L, 1L), !logi_k, g != 0L),
bor3(fod %between% c(-1L, 1L), !logi_k, g != 0L))
expect_equal(or3s(foe %between% c(-1L, 1L), !logi_b, u != 1L),
bor3(foe %between% c(-1L, 1L), !logi_b, u != 1L))
expect_equal(or3s(fof %between% c(-1L, 1L), !logi_q, s != 9L),
bor3(fof %between% c(-1L, 1L), !logi_q, s != 9L))
expect_equal(or3s(fog %between% c(-1L, 1L), , ),
bor3(fog %between% c(-1L, 1L), , ))
expect_equal(or3s(foh %between% c(-1L, 1L), , ),
bor3(foh %between% c(-1L, 1L), , ))
expect_equal(or3s(foi %between% c(-1L, 1L), , ),
bor3(foi %between% c(-1L, 1L), , ))
expect_equal(or3s(foj %between% c(-1L, 1L), , o %between% c(-1L, 1L)),
bor3(foj %between% c(-1L, 1L), , o %between% c(-1L, 1L)))
expect_equal(or3s(fok %between% c(-1L, 1L), , v %between% c(-1L, 1L)),
bor3(fok %between% c(-1L, 1L), , v %between% c(-1L, 1L)))
expect_equal(or3s(fol %between% c(-1L, 1L), , h %between% c(-1L, 1L)),
bor3(fol %between% c(-1L, 1L), , h %between% c(-1L, 1L)))
expect_equal(or3s(fom %between% c(-1L, 1L), !logi_w, ),
bor3(fom %between% c(-1L, 1L), !logi_w, ))
expect_equal(or3s(fon %between% c(-1L, 1L), !logi_k, ),
bor3(fon %between% c(-1L, 1L), !logi_k, ))
expect_equal(or3s(foo %between% c(-1L, 1L), !logi_w, ),
bor3(foo %between% c(-1L, 1L), !logi_w, ))
expect_equal(or3s(fop %between% c(-1L, 1L), !logi_y, p %between% c(-1L, 1L)),
bor3(fop %between% c(-1L, 1L), !logi_y, p %between% c(-1L, 1L)))
expect_equal(or3s(foq %between% c(-1L, 1L), !logi_b, h %between% c(-1L, 1L)),
bor3(foq %between% c(-1L, 1L), !logi_b, h %between% c(-1L, 1L)))
expect_equal(or3s(FOR %between% c(-1L, 1L), !logi_h, v %between% c(-1L, 1L)),
bor3(FOR %between% c(-1L, 1L), !logi_h, v %between% c(-1L, 1L)))
expect_equal(or3s(fos %between% c(-1L, 1L), , ),
bor3(fos %between% c(-1L, 1L), , ))
expect_equal(or3s(fot %between% c(-1L, 1L), , ),
bor3(fot %between% c(-1L, 1L), , ))
expect_equal(or3s(fou %between% c(-1L, 1L), , ),
bor3(fou %between% c(-1L, 1L), , ))
expect_equal(or3s(fov %between% c(-1L, 1L), , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fov %between% c(-1L, 1L), , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fow %between% c(-1L, 1L), , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fow %between% c(-1L, 1L), , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fox %between% c(-1L, 1L), , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fox %between% c(-1L, 1L), , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(foy %between% c(-1L, 1L), !logi_x, ),
bor3(foy %between% c(-1L, 1L), !logi_x, ))
expect_equal(or3s(foz %between% c(-1L, 1L), !logi_b, ),
bor3(foz %between% c(-1L, 1L), !logi_b, ))
expect_equal(or3s(fpa %between% c(-1L, 1L), !logi_o, ),
bor3(fpa %between% c(-1L, 1L), !logi_o, ))
expect_equal(or3s(fpb %between% c(-1L, 1L), !logi_b, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fpb %between% c(-1L, 1L), !logi_b, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fpc %between% c(-1L, 1L), !logi_n, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fpc %between% c(-1L, 1L), !logi_n, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fpd %between% c(-1L, 1L), !logi_c, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fpd %between% c(-1L, 1L), !logi_c, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fpe %between% c(-1L, 1L), , ),
bor3(fpe %between% c(-1L, 1L), , ))
expect_equal(or3s(fpf %between% c(-1L, 1L), , ),
bor3(fpf %between% c(-1L, 1L), , ))
expect_equal(or3s(fpg %between% c(-1L, 1L), , ),
bor3(fpg %between% c(-1L, 1L), , ))
expect_equal(or3s(fph %between% c(-1L, 1L), , e %in% 1:4),
bor3(fph %between% c(-1L, 1L), , e %in% 1:4))
expect_equal(or3s(fpi %between% c(-1L, 1L), , e %in% 1:4),
bor3(fpi %between% c(-1L, 1L), , e %in% 1:4))
expect_equal(or3s(fpj %between% c(-1L, 1L), , u %in% 1:4),
bor3(fpj %between% c(-1L, 1L), , u %in% 1:4))
expect_equal(or3s(fpk %between% c(-1L, 1L), !logi_e, ),
bor3(fpk %between% c(-1L, 1L), !logi_e, ))
expect_equal(or3s(fpl %between% c(-1L, 1L), !logi_x, ),
bor3(fpl %between% c(-1L, 1L), !logi_x, ))
expect_equal(or3s(fpm %between% c(-1L, 1L), !logi_m, ),
bor3(fpm %between% c(-1L, 1L), !logi_m, ))
expect_equal(or3s(fpn %between% c(-1L, 1L), !logi_j, l %in% 1:4),
bor3(fpn %between% c(-1L, 1L), !logi_j, l %in% 1:4))
expect_equal(or3s(fpo %between% c(-1L, 1L), !logi_w, k %in% 1:4),
bor3(fpo %between% c(-1L, 1L), !logi_w, k %in% 1:4))
expect_equal(or3s(fpp %between% c(-1L, 1L), !logi_y, v %in% 1:4),
bor3(fpp %between% c(-1L, 1L), !logi_y, v %in% 1:4))
expect_equal(or3s(fpq %between% c(-1L, 1L), , ),
bor3(fpq %between% c(-1L, 1L), , ))
expect_equal(or3s(fpr %between% c(-1L, 1L), , ),
bor3(fpr %between% c(-1L, 1L), , ))
expect_equal(or3s(fps %between% c(-1L, 1L), , ),
bor3(fps %between% c(-1L, 1L), , ))
expect_equal(or3s(fpt %between% c(-1L, 1L), , l < 0L),
bor3(fpt %between% c(-1L, 1L), , l < 0L))
expect_equal(or3s(fpu %between% c(-1L, 1L), , u < 1L),
bor3(fpu %between% c(-1L, 1L), , u < 1L))
expect_equal(or3s(fpv %between% c(-1L, 1L), , r < 9L),
bor3(fpv %between% c(-1L, 1L), , r < 9L))
expect_equal(or3s(fpw %between% c(-1L, 1L), !logi_d, ),
bor3(fpw %between% c(-1L, 1L), !logi_d, ))
expect_equal(or3s(fpx %between% c(-1L, 1L), !logi_j, ),
bor3(fpx %between% c(-1L, 1L), !logi_j, ))
expect_equal(or3s(fpy %between% c(-1L, 1L), !logi_c, ),
bor3(fpy %between% c(-1L, 1L), !logi_c, ))
expect_equal(or3s(fpz %between% c(-1L, 1L), !logi_d, n < 0L),
bor3(fpz %between% c(-1L, 1L), !logi_d, n < 0L))
expect_equal(or3s(fqa %between% c(-1L, 1L), !logi_g, h < 1L),
bor3(fqa %between% c(-1L, 1L), !logi_g, h < 1L))
expect_equal(or3s(fqb %between% c(-1L, 1L), !logi_f, c < 9L),
bor3(fqb %between% c(-1L, 1L), !logi_f, c < 9L))
expect_equal(or3s(fqc %between% c(-1L, 1L), , ),
bor3(fqc %between% c(-1L, 1L), , ))
expect_equal(or3s(fqd %between% c(-1L, 1L), , ),
bor3(fqd %between% c(-1L, 1L), , ))
expect_equal(or3s(fqe %between% c(-1L, 1L), , ),
bor3(fqe %between% c(-1L, 1L), , ))
expect_equal(or3s(fqf %between% c(-1L, 1L), , f <= 0L),
bor3(fqf %between% c(-1L, 1L), , f <= 0L))
expect_equal(or3s(fqg %between% c(-1L, 1L), , h <= 1L),
bor3(fqg %between% c(-1L, 1L), , h <= 1L))
expect_equal(or3s(fqh %between% c(-1L, 1L), , b <= 9L),
bor3(fqh %between% c(-1L, 1L), , b <= 9L))
expect_equal(or3s(fqi %between% c(-1L, 1L), !logi_q, ),
bor3(fqi %between% c(-1L, 1L), !logi_q, ))
expect_equal(or3s(fqj %between% c(-1L, 1L), !logi_n, ),
bor3(fqj %between% c(-1L, 1L), !logi_n, ))
expect_equal(or3s(fqk %between% c(-1L, 1L), !logi_t, ),
bor3(fqk %between% c(-1L, 1L), !logi_t, ))
expect_equal(or3s(fql %between% c(-1L, 1L), !logi_e, o <= 0L),
bor3(fql %between% c(-1L, 1L), !logi_e, o <= 0L))
expect_equal(or3s(fqm %between% c(-1L, 1L), !logi_i, r <= 1L),
bor3(fqm %between% c(-1L, 1L), !logi_i, r <= 1L))
expect_equal(or3s(fqn %between% c(-1L, 1L), !logi_w, d <= 9L),
bor3(fqn %between% c(-1L, 1L), !logi_w, d <= 9L))
expect_equal(or3s(fqo %between% c(-1L, 1L), , ),
bor3(fqo %between% c(-1L, 1L), , ))
expect_equal(or3s(fqp %between% c(-1L, 1L), , ),
bor3(fqp %between% c(-1L, 1L), , ))
expect_equal(or3s(fqq %between% c(-1L, 1L), , ),
bor3(fqq %between% c(-1L, 1L), , ))
expect_equal(or3s(fqr %between% c(-1L, 1L), , m == 0L),
bor3(fqr %between% c(-1L, 1L), , m == 0L))
expect_equal(or3s(fqs %between% c(-1L, 1L), , d == 1L),
bor3(fqs %between% c(-1L, 1L), , d == 1L))
expect_equal(or3s(fqt %between% c(-1L, 1L), , p == 9L),
bor3(fqt %between% c(-1L, 1L), , p == 9L))
expect_equal(or3s(fqu %between% c(-1L, 1L), !logi_o, ),
bor3(fqu %between% c(-1L, 1L), !logi_o, ))
expect_equal(or3s(fqv %between% c(-1L, 1L), !logi_r, ),
bor3(fqv %between% c(-1L, 1L), !logi_r, ))
expect_equal(or3s(fqw %between% c(-1L, 1L), !logi_n, ),
bor3(fqw %between% c(-1L, 1L), !logi_n, ))
expect_equal(or3s(fqx %between% c(-1L, 1L), !logi_l, b == 0L),
bor3(fqx %between% c(-1L, 1L), !logi_l, b == 0L))
expect_equal(or3s(fqy %between% c(-1L, 1L), !logi_d, d == 1L),
bor3(fqy %between% c(-1L, 1L), !logi_d, d == 1L))
expect_equal(or3s(fqz %between% c(-1L, 1L), !logi_t, h == 9L),
bor3(fqz %between% c(-1L, 1L), !logi_t, h == 9L))
expect_equal(or3s(fra %between% c(-1L, 1L), , ),
bor3(fra %between% c(-1L, 1L), , ))
expect_equal(or3s(frb %between% c(-1L, 1L), , ),
bor3(frb %between% c(-1L, 1L), , ))
expect_equal(or3s(frc %between% c(-1L, 1L), , ),
bor3(frc %between% c(-1L, 1L), , ))
expect_equal(or3s(frd %between% c(-1L, 1L), , m > 0L),
bor3(frd %between% c(-1L, 1L), , m > 0L))
expect_equal(or3s(fre %between% c(-1L, 1L), , w > 1L),
bor3(fre %between% c(-1L, 1L), , w > 1L))
expect_equal(or3s(frf %between% c(-1L, 1L), , x > 9L),
bor3(frf %between% c(-1L, 1L), , x > 9L))
expect_equal(or3s(frg %between% c(-1L, 1L), !logi_d, ),
bor3(frg %between% c(-1L, 1L), !logi_d, ))
expect_equal(or3s(frh %between% c(-1L, 1L), !logi_m, ),
bor3(frh %between% c(-1L, 1L), !logi_m, ))
expect_equal(or3s(fri %between% c(-1L, 1L), !logi_l, ),
bor3(fri %between% c(-1L, 1L), !logi_l, ))
expect_equal(or3s(frj %between% c(-1L, 1L), !logi_z, j > 0L),
bor3(frj %between% c(-1L, 1L), !logi_z, j > 0L))
expect_equal(or3s(frk %between% c(-1L, 1L), !logi_c, d > 1L),
bor3(frk %between% c(-1L, 1L), !logi_c, d > 1L))
expect_equal(or3s(frl %between% c(-1L, 1L), !logi_r, q > 9L),
bor3(frl %between% c(-1L, 1L), !logi_r, q > 9L))
expect_equal(or3s(frm %between% c(-1L, 1L), , ),
bor3(frm %between% c(-1L, 1L), , ))
expect_equal(or3s(frn %between% c(-1L, 1L), , ),
bor3(frn %between% c(-1L, 1L), , ))
expect_equal(or3s(fro %between% c(-1L, 1L), , ),
bor3(fro %between% c(-1L, 1L), , ))
expect_equal(or3s(frp %between% c(-1L, 1L), , t >= 0L),
bor3(frp %between% c(-1L, 1L), , t >= 0L))
expect_equal(or3s(frq %between% c(-1L, 1L), , c >= 1L),
bor3(frq %between% c(-1L, 1L), , c >= 1L))
expect_equal(or3s(frr %between% c(-1L, 1L), , m >= 9L),
bor3(frr %between% c(-1L, 1L), , m >= 9L))
expect_equal(or3s(frs %between% c(-1L, 1L), !logi_e, ),
bor3(frs %between% c(-1L, 1L), !logi_e, ))
expect_equal(or3s(frt %between% c(-1L, 1L), !logi_a, ),
bor3(frt %between% c(-1L, 1L), !logi_a, ))
expect_equal(or3s(fru %between% c(-1L, 1L), !logi_l, ),
bor3(fru %between% c(-1L, 1L), !logi_l, ))
expect_equal(or3s(frv %between% c(-1L, 1L), !logi_k, d >= 0L),
bor3(frv %between% c(-1L, 1L), !logi_k, d >= 0L))
expect_equal(or3s(frw %between% c(-1L, 1L), !logi_t, l >= 1L),
bor3(frw %between% c(-1L, 1L), !logi_t, l >= 1L))
expect_equal(or3s(frx %between% c(-1L, 1L), !logi_b, b >= 9L),
bor3(frx %between% c(-1L, 1L), !logi_b, b >= 9L))
expect_equal(or3s(fry %between% c(-1L, 1L), , ),
bor3(fry %between% c(-1L, 1L), , ))
expect_equal(or3s(frz %between% c(-1L, 1L), , ),
bor3(frz %between% c(-1L, 1L), , ))
expect_equal(or3s(fsa %between% c(-1L, 1L), , ),
bor3(fsa %between% c(-1L, 1L), , ))
expect_equal(or3s(fsb %between% c(-1L, 1L), , logi_h),
bor3(fsb %between% c(-1L, 1L), , logi_h))
expect_equal(or3s(fsc %between% c(-1L, 1L), , logi_h),
bor3(fsc %between% c(-1L, 1L), , logi_h))
expect_equal(or3s(fsd %between% c(-1L, 1L), , logi_q),
bor3(fsd %between% c(-1L, 1L), , logi_q))
expect_equal(or3s(fse %between% c(-1L, 1L), u != 0L, ),
bor3(fse %between% c(-1L, 1L), u != 0L, ))
expect_equal(or3s(fsf %between% c(-1L, 1L), t != 1L, ),
bor3(fsf %between% c(-1L, 1L), t != 1L, ))
expect_equal(or3s(fsg %between% c(-1L, 1L), u != 9L, ),
bor3(fsg %between% c(-1L, 1L), u != 9L, ))
expect_equal(or3s(fsh %between% c(-1L, 1L), f != 0L, logi_h),
bor3(fsh %between% c(-1L, 1L), f != 0L, logi_h))
expect_equal(or3s(fsi %between% c(-1L, 1L), g != 1L, logi_d),
bor3(fsi %between% c(-1L, 1L), g != 1L, logi_d))
expect_equal(or3s(fsj %between% c(-1L, 1L), n != 9L, logi_i),
bor3(fsj %between% c(-1L, 1L), n != 9L, logi_i))
expect_equal(or3s(fsk %between% c(-1L, 1L), , ),
bor3(fsk %between% c(-1L, 1L), , ))
expect_equal(or3s(fsl %between% c(-1L, 1L), , ),
bor3(fsl %between% c(-1L, 1L), , ))
expect_equal(or3s(fsm %between% c(-1L, 1L), , ),
bor3(fsm %between% c(-1L, 1L), , ))
expect_equal(or3s(fsn %between% c(-1L, 1L), , !logi_y),
bor3(fsn %between% c(-1L, 1L), , !logi_y))
expect_equal(or3s(fso %between% c(-1L, 1L), , !logi_w),
bor3(fso %between% c(-1L, 1L), , !logi_w))
expect_equal(or3s(fsp %between% c(-1L, 1L), , !logi_z),
bor3(fsp %between% c(-1L, 1L), , !logi_z))
expect_equal(or3s(fsq %between% c(-1L, 1L), b != 0L, ),
bor3(fsq %between% c(-1L, 1L), b != 0L, ))
expect_equal(or3s(fsr %between% c(-1L, 1L), c != 1L, ),
bor3(fsr %between% c(-1L, 1L), c != 1L, ))
expect_equal(or3s(fss %between% c(-1L, 1L), m != 9L, ),
bor3(fss %between% c(-1L, 1L), m != 9L, ))
expect_equal(or3s(fst %between% c(-1L, 1L), s != 0L, !logi_d),
bor3(fst %between% c(-1L, 1L), s != 0L, !logi_d))
expect_equal(or3s(fsu %between% c(-1L, 1L), m != 1L, !logi_q),
bor3(fsu %between% c(-1L, 1L), m != 1L, !logi_q))
expect_equal(or3s(fsv %between% c(-1L, 1L), x != 9L, !logi_n),
bor3(fsv %between% c(-1L, 1L), x != 9L, !logi_n))
expect_equal(or3s(fsw %between% c(-1L, 1L), , ),
bor3(fsw %between% c(-1L, 1L), , ))
expect_equal(or3s(fsx %between% c(-1L, 1L), , ),
bor3(fsx %between% c(-1L, 1L), , ))
expect_equal(or3s(fsy %between% c(-1L, 1L), , ),
bor3(fsy %between% c(-1L, 1L), , ))
expect_equal(or3s(fsz %between% c(-1L, 1L), , m != 0L),
bor3(fsz %between% c(-1L, 1L), , m != 0L))
expect_equal(or3s(fta %between% c(-1L, 1L), , n != 1L),
bor3(fta %between% c(-1L, 1L), , n != 1L))
expect_equal(or3s(ftb %between% c(-1L, 1L), , n != 9L),
bor3(ftb %between% c(-1L, 1L), , n != 9L))
expect_equal(or3s(ftc %between% c(-1L, 1L), l != 0L, ),
bor3(ftc %between% c(-1L, 1L), l != 0L, ))
expect_equal(or3s(ftd %between% c(-1L, 1L), b != 1L, ),
bor3(ftd %between% c(-1L, 1L), b != 1L, ))
expect_equal(or3s(fte %between% c(-1L, 1L), p != 9L, ),
bor3(fte %between% c(-1L, 1L), p != 9L, ))
expect_equal(or3s(ftf %between% c(-1L, 1L), h != 0L, l != 0L),
bor3(ftf %between% c(-1L, 1L), h != 0L, l != 0L))
expect_equal(or3s(ftg %between% c(-1L, 1L), n != 1L, l != 1L),
bor3(ftg %between% c(-1L, 1L), n != 1L, l != 1L))
expect_equal(or3s(fth %between% c(-1L, 1L), i != 9L, e != 9L),
bor3(fth %between% c(-1L, 1L), i != 9L, e != 9L))
expect_equal(or3s(fti %between% c(-1L, 1L), , ),
bor3(fti %between% c(-1L, 1L), , ))
expect_equal(or3s(ftj %between% c(-1L, 1L), , ),
bor3(ftj %between% c(-1L, 1L), , ))
expect_equal(or3s(ftk %between% c(-1L, 1L), , ),
bor3(ftk %between% c(-1L, 1L), , ))
expect_equal(or3s(ftl %between% c(-1L, 1L), , i %between% c(-1L, 1L)),
bor3(ftl %between% c(-1L, 1L), , i %between% c(-1L, 1L)))
expect_equal(or3s(ftm %between% c(-1L, 1L), , k %between% c(-1L, 1L)),
bor3(ftm %between% c(-1L, 1L), , k %between% c(-1L, 1L)))
expect_equal(or3s(ftn %between% c(-1L, 1L), , g %between% c(-1L, 1L)),
bor3(ftn %between% c(-1L, 1L), , g %between% c(-1L, 1L)))
expect_equal(or3s(fto %between% c(-1L, 1L), e != 0L, ),
bor3(fto %between% c(-1L, 1L), e != 0L, ))
expect_equal(or3s(ftp %between% c(-1L, 1L), d != 1L, ),
bor3(ftp %between% c(-1L, 1L), d != 1L, ))
expect_equal(or3s(ftq %between% c(-1L, 1L), z != 9L, ),
bor3(ftq %between% c(-1L, 1L), z != 9L, ))
expect_equal(or3s(ftr %between% c(-1L, 1L), n != 0L, s %between% c(-1L, 1L)),
bor3(ftr %between% c(-1L, 1L), n != 0L, s %between% c(-1L, 1L)))
expect_equal(or3s(fts %between% c(-1L, 1L), x != 1L, i %between% c(-1L, 1L)),
bor3(fts %between% c(-1L, 1L), x != 1L, i %between% c(-1L, 1L)))
expect_equal(or3s(ftt %between% c(-1L, 1L), o != 9L, z %between% c(-1L, 1L)),
bor3(ftt %between% c(-1L, 1L), o != 9L, z %between% c(-1L, 1L)))
expect_equal(or3s(ftu %between% c(-1L, 1L), , ),
bor3(ftu %between% c(-1L, 1L), , ))
expect_equal(or3s(ftv %between% c(-1L, 1L), , ),
bor3(ftv %between% c(-1L, 1L), , ))
expect_equal(or3s(ftw %between% c(-1L, 1L), , ),
bor3(ftw %between% c(-1L, 1L), , ))
expect_equal(or3s(ftx %between% c(-1L, 1L), , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ftx %between% c(-1L, 1L), , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fty %between% c(-1L, 1L), , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fty %between% c(-1L, 1L), , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ftz %between% c(-1L, 1L), , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ftz %between% c(-1L, 1L), , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fua %between% c(-1L, 1L), p != 0L, ),
bor3(fua %between% c(-1L, 1L), p != 0L, ))
expect_equal(or3s(fub %between% c(-1L, 1L), m != 1L, ),
bor3(fub %between% c(-1L, 1L), m != 1L, ))
expect_equal(or3s(fuc %between% c(-1L, 1L), i != 9L, ),
bor3(fuc %between% c(-1L, 1L), i != 9L, ))
expect_equal(or3s(fud %between% c(-1L, 1L), x != 0L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fud %between% c(-1L, 1L), x != 0L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fue %between% c(-1L, 1L), a != 1L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fue %between% c(-1L, 1L), a != 1L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fuf %between% c(-1L, 1L), y != 9L, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fuf %between% c(-1L, 1L), y != 9L, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(fug %between% c(-1L, 1L), , ),
bor3(fug %between% c(-1L, 1L), , ))
expect_equal(or3s(fuh %between% c(-1L, 1L), , ),
bor3(fuh %between% c(-1L, 1L), , ))
expect_equal(or3s(fui %between% c(-1L, 1L), , ),
bor3(fui %between% c(-1L, 1L), , ))
expect_equal(or3s(fuj %between% c(-1L, 1L), , a %in% 1:4),
bor3(fuj %between% c(-1L, 1L), , a %in% 1:4))
expect_equal(or3s(fuk %between% c(-1L, 1L), , o %in% 1:4),
bor3(fuk %between% c(-1L, 1L), , o %in% 1:4))
expect_equal(or3s(ful %between% c(-1L, 1L), , l %in% 1:4),
bor3(ful %between% c(-1L, 1L), , l %in% 1:4))
expect_equal(or3s(fum %between% c(-1L, 1L), q != 0L, ),
bor3(fum %between% c(-1L, 1L), q != 0L, ))
expect_equal(or3s(fun %between% c(-1L, 1L), y != 1L, ),
bor3(fun %between% c(-1L, 1L), y != 1L, ))
expect_equal(or3s(fuo %between% c(-1L, 1L), k != 9L, ),
bor3(fuo %between% c(-1L, 1L), k != 9L, ))
expect_equal(or3s(fup %between% c(-1L, 1L), t != 0L, w %in% 1:4),
bor3(fup %between% c(-1L, 1L), t != 0L, w %in% 1:4))
expect_equal(or3s(fuq %between% c(-1L, 1L), g != 1L, q %in% 1:4),
bor3(fuq %between% c(-1L, 1L), g != 1L, q %in% 1:4))
expect_equal(or3s(fur %between% c(-1L, 1L), x != 9L, c %in% 1:4),
bor3(fur %between% c(-1L, 1L), x != 9L, c %in% 1:4))
expect_equal(or3s(fus %between% c(-1L, 1L), , ),
bor3(fus %between% c(-1L, 1L), , ))
expect_equal(or3s(fut %between% c(-1L, 1L), , ),
bor3(fut %between% c(-1L, 1L), , ))
expect_equal(or3s(fuu %between% c(-1L, 1L), , ),
bor3(fuu %between% c(-1L, 1L), , ))
expect_equal(or3s(fuv %between% c(-1L, 1L), , o < 0L),
bor3(fuv %between% c(-1L, 1L), , o < 0L))
expect_equal(or3s(fuw %between% c(-1L, 1L), , z < 1L),
bor3(fuw %between% c(-1L, 1L), , z < 1L))
expect_equal(or3s(fux %between% c(-1L, 1L), , l < 9L),
bor3(fux %between% c(-1L, 1L), , l < 9L))
expect_equal(or3s(fuy %between% c(-1L, 1L), k != 0L, ),
bor3(fuy %between% c(-1L, 1L), k != 0L, ))
expect_equal(or3s(fuz %between% c(-1L, 1L), e != 1L, ),
bor3(fuz %between% c(-1L, 1L), e != 1L, ))
expect_equal(or3s(fva %between% c(-1L, 1L), x != 9L, ),
bor3(fva %between% c(-1L, 1L), x != 9L, ))
expect_equal(or3s(fvb %between% c(-1L, 1L), n != 0L, b < 0L),
bor3(fvb %between% c(-1L, 1L), n != 0L, b < 0L))
expect_equal(or3s(fvc %between% c(-1L, 1L), i != 1L, h < 1L),
bor3(fvc %between% c(-1L, 1L), i != 1L, h < 1L))
expect_equal(or3s(fvd %between% c(-1L, 1L), x != 9L, o < 9L),
bor3(fvd %between% c(-1L, 1L), x != 9L, o < 9L))
expect_equal(or3s(fve %between% c(-1L, 1L), , ),
bor3(fve %between% c(-1L, 1L), , ))
expect_equal(or3s(fvf %between% c(-1L, 1L), , ),
bor3(fvf %between% c(-1L, 1L), , ))
expect_equal(or3s(fvg %between% c(-1L, 1L), , ),
bor3(fvg %between% c(-1L, 1L), , ))
expect_equal(or3s(fvh %between% c(-1L, 1L), , o <= 0L),
bor3(fvh %between% c(-1L, 1L), , o <= 0L))
expect_equal(or3s(fvi %between% c(-1L, 1L), , d <= 1L),
bor3(fvi %between% c(-1L, 1L), , d <= 1L))
expect_equal(or3s(fvj %between% c(-1L, 1L), , s <= 9L),
bor3(fvj %between% c(-1L, 1L), , s <= 9L))
expect_equal(or3s(fvk %between% c(-1L, 1L), u != 0L, ),
bor3(fvk %between% c(-1L, 1L), u != 0L, ))
expect_equal(or3s(fvl %between% c(-1L, 1L), f != 1L, ),
bor3(fvl %between% c(-1L, 1L), f != 1L, ))
expect_equal(or3s(fvm %between% c(-1L, 1L), o != 9L, ),
bor3(fvm %between% c(-1L, 1L), o != 9L, ))
expect_equal(or3s(fvn %between% c(-1L, 1L), z != 0L, b <= 0L),
bor3(fvn %between% c(-1L, 1L), z != 0L, b <= 0L))
expect_equal(or3s(fvo %between% c(-1L, 1L), g != 1L, j <= 1L),
bor3(fvo %between% c(-1L, 1L), g != 1L, j <= 1L))
expect_equal(or3s(fvp %between% c(-1L, 1L), w != 9L, v <= 9L),
bor3(fvp %between% c(-1L, 1L), w != 9L, v <= 9L))
expect_equal(or3s(fvq %between% c(-1L, 1L), , ),
bor3(fvq %between% c(-1L, 1L), , ))
expect_equal(or3s(fvr %between% c(-1L, 1L), , ),
bor3(fvr %between% c(-1L, 1L), , ))
expect_equal(or3s(fvs %between% c(-1L, 1L), , ),
bor3(fvs %between% c(-1L, 1L), , ))
expect_equal(or3s(fvt %between% c(-1L, 1L), , y == 0L),
bor3(fvt %between% c(-1L, 1L), , y == 0L))
expect_equal(or3s(fvu %between% c(-1L, 1L), , e == 1L),
bor3(fvu %between% c(-1L, 1L), , e == 1L))
expect_equal(or3s(fvv %between% c(-1L, 1L), , j == 9L),
bor3(fvv %between% c(-1L, 1L), , j == 9L))
expect_equal(or3s(fvw %between% c(-1L, 1L), j != 0L, ),
bor3(fvw %between% c(-1L, 1L), j != 0L, ))
expect_equal(or3s(fvx %between% c(-1L, 1L), a != 1L, ),
bor3(fvx %between% c(-1L, 1L), a != 1L, ))
expect_equal(or3s(fvy %between% c(-1L, 1L), u != 9L, ),
bor3(fvy %between% c(-1L, 1L), u != 9L, ))
expect_equal(or3s(fvz %between% c(-1L, 1L), d != 0L, k == 0L),
bor3(fvz %between% c(-1L, 1L), d != 0L, k == 0L))
expect_equal(or3s(fwa %between% c(-1L, 1L), m != 1L, a == 1L),
bor3(fwa %between% c(-1L, 1L), m != 1L, a == 1L))
expect_equal(or3s(fwb %between% c(-1L, 1L), h != 9L, j == 9L),
bor3(fwb %between% c(-1L, 1L), h != 9L, j == 9L))
expect_equal(or3s(fwc %between% c(-1L, 1L), , ),
bor3(fwc %between% c(-1L, 1L), , ))
expect_equal(or3s(fwd %between% c(-1L, 1L), , ),
bor3(fwd %between% c(-1L, 1L), , ))
expect_equal(or3s(fwe %between% c(-1L, 1L), , ),
bor3(fwe %between% c(-1L, 1L), , ))
expect_equal(or3s(fwf %between% c(-1L, 1L), , c > 0L),
bor3(fwf %between% c(-1L, 1L), , c > 0L))
expect_equal(or3s(fwg %between% c(-1L, 1L), , a > 1L),
bor3(fwg %between% c(-1L, 1L), , a > 1L))
expect_equal(or3s(fwh %between% c(-1L, 1L), , j > 9L),
bor3(fwh %between% c(-1L, 1L), , j > 9L))
expect_equal(or3s(fwi %between% c(-1L, 1L), t != 0L, ),
bor3(fwi %between% c(-1L, 1L), t != 0L, ))
expect_equal(or3s(fwj %between% c(-1L, 1L), b != 1L, ),
bor3(fwj %between% c(-1L, 1L), b != 1L, ))
expect_equal(or3s(fwk %between% c(-1L, 1L), t != 9L, ),
bor3(fwk %between% c(-1L, 1L), t != 9L, ))
expect_equal(or3s(fwl %between% c(-1L, 1L), g != 0L, y > 0L),
bor3(fwl %between% c(-1L, 1L), g != 0L, y > 0L))
expect_equal(or3s(fwm %between% c(-1L, 1L), f != 1L, c > 1L),
bor3(fwm %between% c(-1L, 1L), f != 1L, c > 1L))
expect_equal(or3s(fwn %between% c(-1L, 1L), h != 9L, m > 9L),
bor3(fwn %between% c(-1L, 1L), h != 9L, m > 9L))
expect_equal(or3s(fwo %between% c(-1L, 1L), , ),
bor3(fwo %between% c(-1L, 1L), , ))
expect_equal(or3s(fwp %between% c(-1L, 1L), , ),
bor3(fwp %between% c(-1L, 1L), , ))
expect_equal(or3s(fwq %between% c(-1L, 1L), , ),
bor3(fwq %between% c(-1L, 1L), , ))
expect_equal(or3s(fwr %between% c(-1L, 1L), , m >= 0L),
bor3(fwr %between% c(-1L, 1L), , m >= 0L))
expect_equal(or3s(fws %between% c(-1L, 1L), , u >= 1L),
bor3(fws %between% c(-1L, 1L), , u >= 1L))
expect_equal(or3s(fwt %between% c(-1L, 1L), , r >= 9L),
bor3(fwt %between% c(-1L, 1L), , r >= 9L))
expect_equal(or3s(fwu %between% c(-1L, 1L), o != 0L, ),
bor3(fwu %between% c(-1L, 1L), o != 0L, ))
expect_equal(or3s(fwv %between% c(-1L, 1L), q != 1L, ),
bor3(fwv %between% c(-1L, 1L), q != 1L, ))
expect_equal(or3s(fww %between% c(-1L, 1L), n != 9L, ),
bor3(fww %between% c(-1L, 1L), n != 9L, ))
expect_equal(or3s(fwx %between% c(-1L, 1L), n != 0L, g >= 0L),
bor3(fwx %between% c(-1L, 1L), n != 0L, g >= 0L))
expect_equal(or3s(fwy %between% c(-1L, 1L), i != 1L, u >= 1L),
bor3(fwy %between% c(-1L, 1L), i != 1L, u >= 1L))
expect_equal(or3s(fwz %between% c(-1L, 1L), a != 9L, z >= 9L),
bor3(fwz %between% c(-1L, 1L), a != 9L, z >= 9L))
expect_equal(or3s(fxa %between% c(-1L, 1L), , ),
bor3(fxa %between% c(-1L, 1L), , ))
expect_equal(or3s(fxb %between% c(-1L, 1L), , ),
bor3(fxb %between% c(-1L, 1L), , ))
expect_equal(or3s(fxc %between% c(-1L, 1L), , ),
bor3(fxc %between% c(-1L, 1L), , ))
expect_equal(or3s(fxd %between% c(-1L, 1L), , logi_e),
bor3(fxd %between% c(-1L, 1L), , logi_e))
expect_equal(or3s(fxe %between% c(-1L, 1L), , logi_h),
bor3(fxe %between% c(-1L, 1L), , logi_h))
expect_equal(or3s(fxf %between% c(-1L, 1L), , logi_l),
bor3(fxf %between% c(-1L, 1L), , logi_l))
expect_equal(or3s(fxg %between% c(-1L, 1L), p %between% c(-1L, 1L), ),
bor3(fxg %between% c(-1L, 1L), p %between% c(-1L, 1L), ))
expect_equal(or3s(fxh %between% c(-1L, 1L), b %between% c(-1L, 1L), ),
bor3(fxh %between% c(-1L, 1L), b %between% c(-1L, 1L), ))
expect_equal(or3s(fxi %between% c(-1L, 1L), s %between% c(-1L, 1L), ),
bor3(fxi %between% c(-1L, 1L), s %between% c(-1L, 1L), ))
expect_equal(or3s(fxj %between% c(-1L, 1L), v %between% c(-1L, 1L), logi_u),
bor3(fxj %between% c(-1L, 1L), v %between% c(-1L, 1L), logi_u))
expect_equal(or3s(fxk %between% c(-1L, 1L), s %between% c(-1L, 1L), logi_b),
bor3(fxk %between% c(-1L, 1L), s %between% c(-1L, 1L), logi_b))
expect_equal(or3s(fxl %between% c(-1L, 1L), f %between% c(-1L, 1L), logi_q),
bor3(fxl %between% c(-1L, 1L), f %between% c(-1L, 1L), logi_q))
expect_equal(or3s(fxm %between% c(-1L, 1L), , ),
bor3(fxm %between% c(-1L, 1L), , ))
expect_equal(or3s(fxn %between% c(-1L, 1L), , ),
bor3(fxn %between% c(-1L, 1L), , ))
expect_equal(or3s(fxo %between% c(-1L, 1L), , ),
bor3(fxo %between% c(-1L, 1L), , ))
expect_equal(or3s(fxp %between% c(-1L, 1L), , !logi_l),
bor3(fxp %between% c(-1L, 1L), , !logi_l))
expect_equal(or3s(fxq %between% c(-1L, 1L), , !logi_u),
bor3(fxq %between% c(-1L, 1L), , !logi_u))
expect_equal(or3s(fxr %between% c(-1L, 1L), , !logi_u),
bor3(fxr %between% c(-1L, 1L), , !logi_u))
expect_equal(or3s(fxs %between% c(-1L, 1L), c %between% c(-1L, 1L), ),
bor3(fxs %between% c(-1L, 1L), c %between% c(-1L, 1L), ))
expect_equal(or3s(fxt %between% c(-1L, 1L), h %between% c(-1L, 1L), ),
bor3(fxt %between% c(-1L, 1L), h %between% c(-1L, 1L), ))
expect_equal(or3s(fxu %between% c(-1L, 1L), a %between% c(-1L, 1L), ),
bor3(fxu %between% c(-1L, 1L), a %between% c(-1L, 1L), ))
expect_equal(or3s(fxv %between% c(-1L, 1L), t %between% c(-1L, 1L), !logi_o),
bor3(fxv %between% c(-1L, 1L), t %between% c(-1L, 1L), !logi_o))
expect_equal(or3s(fxw %between% c(-1L, 1L), f %between% c(-1L, 1L), !logi_l),
bor3(fxw %between% c(-1L, 1L), f %between% c(-1L, 1L), !logi_l))
expect_equal(or3s(fxx %between% c(-1L, 1L), z %between% c(-1L, 1L), !logi_c),
bor3(fxx %between% c(-1L, 1L), z %between% c(-1L, 1L), !logi_c))
expect_equal(or3s(fxy %between% c(-1L, 1L), , ),
bor3(fxy %between% c(-1L, 1L), , ))
expect_equal(or3s(fxz %between% c(-1L, 1L), , ),
bor3(fxz %between% c(-1L, 1L), , ))
expect_equal(or3s(fya %between% c(-1L, 1L), , ),
bor3(fya %between% c(-1L, 1L), , ))
expect_equal(or3s(fyb %between% c(-1L, 1L), , y != 0L),
bor3(fyb %between% c(-1L, 1L), , y != 0L))
expect_equal(or3s(fyc %between% c(-1L, 1L), , r != 1L),
bor3(fyc %between% c(-1L, 1L), , r != 1L))
expect_equal(or3s(fyd %between% c(-1L, 1L), , y != 9L),
bor3(fyd %between% c(-1L, 1L), , y != 9L))
expect_equal(or3s(fye %between% c(-1L, 1L), n %between% c(-1L, 1L), ),
bor3(fye %between% c(-1L, 1L), n %between% c(-1L, 1L), ))
expect_equal(or3s(fyf %between% c(-1L, 1L), e %between% c(-1L, 1L), ),
bor3(fyf %between% c(-1L, 1L), e %between% c(-1L, 1L), ))
expect_equal(or3s(fyg %between% c(-1L, 1L), k %between% c(-1L, 1L), ),
bor3(fyg %between% c(-1L, 1L), k %between% c(-1L, 1L), ))
expect_equal(or3s(fyh %between% c(-1L, 1L), i %between% c(-1L, 1L), s != 0L),
bor3(fyh %between% c(-1L, 1L), i %between% c(-1L, 1L), s != 0L))
expect_equal(or3s(fyi %between% c(-1L, 1L), q %between% c(-1L, 1L), k != 1L),
bor3(fyi %between% c(-1L, 1L), q %between% c(-1L, 1L), k != 1L))
expect_equal(or3s(fyj %between% c(-1L, 1L), c %between% c(-1L, 1L), q != 9L),
bor3(fyj %between% c(-1L, 1L), c %between% c(-1L, 1L), q != 9L))
expect_equal(or3s(fyk %between% c(-1L, 1L), , ),
bor3(fyk %between% c(-1L, 1L), , ))
expect_equal(or3s(fyl %between% c(-1L, 1L), , ),
bor3(fyl %between% c(-1L, 1L), , ))
expect_equal(or3s(fym %between% c(-1L, 1L), , ),
bor3(fym %between% c(-1L, 1L), , ))
expect_equal(or3s(fyn %between% c(-1L, 1L), , n %between% c(-1L, 1L)),
bor3(fyn %between% c(-1L, 1L), , n %between% c(-1L, 1L)))
expect_equal(or3s(fyo %between% c(-1L, 1L), , i %between% c(-1L, 1L)),
bor3(fyo %between% c(-1L, 1L), , i %between% c(-1L, 1L)))
expect_equal(or3s(fyp %between% c(-1L, 1L), , t %between% c(-1L, 1L)),
bor3(fyp %between% c(-1L, 1L), , t %between% c(-1L, 1L)))
expect_equal(or3s(fyq %between% c(-1L, 1L), x %between% c(-1L, 1L), ),
bor3(fyq %between% c(-1L, 1L), x %between% c(-1L, 1L), ))
expect_equal(or3s(fyr %between% c(-1L, 1L), s %between% c(-1L, 1L), ),
bor3(fyr %between% c(-1L, 1L), s %between% c(-1L, 1L), ))
expect_equal(or3s(fys %between% c(-1L, 1L), g %between% c(-1L, 1L), ),
bor3(fys %between% c(-1L, 1L), g %between% c(-1L, 1L), ))
expect_equal(or3s(fyt %between% c(-1L, 1L), v %between% c(-1L, 1L), u %between% c(-1L, 1L)),
bor3(fyt %between% c(-1L, 1L), v %between% c(-1L, 1L), u %between% c(-1L, 1L)))
expect_equal(or3s(fyu %between% c(-1L, 1L), d %between% c(-1L, 1L), b %between% c(-1L, 1L)),
bor3(fyu %between% c(-1L, 1L), d %between% c(-1L, 1L), b %between% c(-1L, 1L)))
expect_equal(or3s(fyv %between% c(-1L, 1L), i %between% c(-1L, 1L), q %between% c(-1L, 1L)),
bor3(fyv %between% c(-1L, 1L), i %between% c(-1L, 1L), q %between% c(-1L, 1L)))
expect_equal(or3s(fyw %between% c(-1L, 1L), , ),
bor3(fyw %between% c(-1L, 1L), , ))
expect_equal(or3s(fyx %between% c(-1L, 1L), , ),
bor3(fyx %between% c(-1L, 1L), , ))
expect_equal(or3s(fyy %between% c(-1L, 1L), , ),
bor3(fyy %between% c(-1L, 1L), , ))
expect_equal(or3s(fyz %between% c(-1L, 1L), , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(fyz %between% c(-1L, 1L), , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ga %between% c(-1L, 1L), , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ga %between% c(-1L, 1L), , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gb %between% c(-1L, 1L), , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gb %between% c(-1L, 1L), , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gc %between% c(-1L, 1L), h %between% c(-1L, 1L), ),
bor3(gc %between% c(-1L, 1L), h %between% c(-1L, 1L), ))
expect_equal(or3s(gd %between% c(-1L, 1L), r %between% c(-1L, 1L), ),
bor3(gd %between% c(-1L, 1L), r %between% c(-1L, 1L), ))
expect_equal(or3s(ge %between% c(-1L, 1L), g %between% c(-1L, 1L), ),
bor3(ge %between% c(-1L, 1L), g %between% c(-1L, 1L), ))
expect_equal(or3s(gf %between% c(-1L, 1L), j %between% c(-1L, 1L), j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gf %between% c(-1L, 1L), j %between% c(-1L, 1L), j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gg %between% c(-1L, 1L), v %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gg %between% c(-1L, 1L), v %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gh %between% c(-1L, 1L), h %between% c(-1L, 1L), c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gh %between% c(-1L, 1L), h %between% c(-1L, 1L), c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gi %between% c(-1L, 1L), , ),
bor3(gi %between% c(-1L, 1L), , ))
expect_equal(or3s(gj %between% c(-1L, 1L), , ),
bor3(gj %between% c(-1L, 1L), , ))
expect_equal(or3s(gk %between% c(-1L, 1L), , ),
bor3(gk %between% c(-1L, 1L), , ))
expect_equal(or3s(gl %between% c(-1L, 1L), , u %in% 1:4),
bor3(gl %between% c(-1L, 1L), , u %in% 1:4))
expect_equal(or3s(gm %between% c(-1L, 1L), , r %in% 1:4),
bor3(gm %between% c(-1L, 1L), , r %in% 1:4))
expect_equal(or3s(gn %between% c(-1L, 1L), , x %in% 1:4),
bor3(gn %between% c(-1L, 1L), , x %in% 1:4))
expect_equal(or3s(go %between% c(-1L, 1L), v %between% c(-1L, 1L), ),
bor3(go %between% c(-1L, 1L), v %between% c(-1L, 1L), ))
expect_equal(or3s(gp %between% c(-1L, 1L), u %between% c(-1L, 1L), ),
bor3(gp %between% c(-1L, 1L), u %between% c(-1L, 1L), ))
expect_equal(or3s(gq %between% c(-1L, 1L), m %between% c(-1L, 1L), ),
bor3(gq %between% c(-1L, 1L), m %between% c(-1L, 1L), ))
expect_equal(or3s(gr %between% c(-1L, 1L), v %between% c(-1L, 1L), t %in% 1:4),
bor3(gr %between% c(-1L, 1L), v %between% c(-1L, 1L), t %in% 1:4))
expect_equal(or3s(gs %between% c(-1L, 1L), t %between% c(-1L, 1L), x %in% 1:4),
bor3(gs %between% c(-1L, 1L), t %between% c(-1L, 1L), x %in% 1:4))
expect_equal(or3s(gt %between% c(-1L, 1L), m %between% c(-1L, 1L), t %in% 1:4),
bor3(gt %between% c(-1L, 1L), m %between% c(-1L, 1L), t %in% 1:4))
expect_equal(or3s(gu %between% c(-1L, 1L), , ),
bor3(gu %between% c(-1L, 1L), , ))
expect_equal(or3s(gv %between% c(-1L, 1L), , ),
bor3(gv %between% c(-1L, 1L), , ))
expect_equal(or3s(gw %between% c(-1L, 1L), , ),
bor3(gw %between% c(-1L, 1L), , ))
expect_equal(or3s(gx %between% c(-1L, 1L), , q < 0L),
bor3(gx %between% c(-1L, 1L), , q < 0L))
expect_equal(or3s(gy %between% c(-1L, 1L), , o < 1L),
bor3(gy %between% c(-1L, 1L), , o < 1L))
expect_equal(or3s(gz %between% c(-1L, 1L), , u < 9L),
bor3(gz %between% c(-1L, 1L), , u < 9L))
expect_equal(or3s(gaa %between% c(-1L, 1L), y %between% c(-1L, 1L), ),
bor3(gaa %between% c(-1L, 1L), y %between% c(-1L, 1L), ))
expect_equal(or3s(gab %between% c(-1L, 1L), h %between% c(-1L, 1L), ),
bor3(gab %between% c(-1L, 1L), h %between% c(-1L, 1L), ))
expect_equal(or3s(gac %between% c(-1L, 1L), t %between% c(-1L, 1L), ),
bor3(gac %between% c(-1L, 1L), t %between% c(-1L, 1L), ))
expect_equal(or3s(gad %between% c(-1L, 1L), i %between% c(-1L, 1L), s < 0L),
bor3(gad %between% c(-1L, 1L), i %between% c(-1L, 1L), s < 0L))
expect_equal(or3s(gae %between% c(-1L, 1L), e %between% c(-1L, 1L), e < 1L),
bor3(gae %between% c(-1L, 1L), e %between% c(-1L, 1L), e < 1L))
expect_equal(or3s(gaf %between% c(-1L, 1L), w %between% c(-1L, 1L), s < 9L),
bor3(gaf %between% c(-1L, 1L), w %between% c(-1L, 1L), s < 9L))
expect_equal(or3s(gag %between% c(-1L, 1L), , ),
bor3(gag %between% c(-1L, 1L), , ))
expect_equal(or3s(gah %between% c(-1L, 1L), , ),
bor3(gah %between% c(-1L, 1L), , ))
expect_equal(or3s(gai %between% c(-1L, 1L), , ),
bor3(gai %between% c(-1L, 1L), , ))
expect_equal(or3s(gaj %between% c(-1L, 1L), , k <= 0L),
bor3(gaj %between% c(-1L, 1L), , k <= 0L))
expect_equal(or3s(gak %between% c(-1L, 1L), , c <= 1L),
bor3(gak %between% c(-1L, 1L), , c <= 1L))
expect_equal(or3s(gal %between% c(-1L, 1L), , h <= 9L),
bor3(gal %between% c(-1L, 1L), , h <= 9L))
expect_equal(or3s(gam %between% c(-1L, 1L), n %between% c(-1L, 1L), ),
bor3(gam %between% c(-1L, 1L), n %between% c(-1L, 1L), ))
expect_equal(or3s(gan %between% c(-1L, 1L), i %between% c(-1L, 1L), ),
bor3(gan %between% c(-1L, 1L), i %between% c(-1L, 1L), ))
expect_equal(or3s(gao %between% c(-1L, 1L), n %between% c(-1L, 1L), ),
bor3(gao %between% c(-1L, 1L), n %between% c(-1L, 1L), ))
expect_equal(or3s(gap %between% c(-1L, 1L), n %between% c(-1L, 1L), f <= 0L),
bor3(gap %between% c(-1L, 1L), n %between% c(-1L, 1L), f <= 0L))
expect_equal(or3s(gaq %between% c(-1L, 1L), q %between% c(-1L, 1L), d <= 1L),
bor3(gaq %between% c(-1L, 1L), q %between% c(-1L, 1L), d <= 1L))
expect_equal(or3s(gar %between% c(-1L, 1L), b %between% c(-1L, 1L), z <= 9L),
bor3(gar %between% c(-1L, 1L), b %between% c(-1L, 1L), z <= 9L))
expect_equal(or3s(gas %between% c(-1L, 1L), , ),
bor3(gas %between% c(-1L, 1L), , ))
expect_equal(or3s(gat %between% c(-1L, 1L), , ),
bor3(gat %between% c(-1L, 1L), , ))
expect_equal(or3s(gau %between% c(-1L, 1L), , ),
bor3(gau %between% c(-1L, 1L), , ))
expect_equal(or3s(gav %between% c(-1L, 1L), , d == 0L),
bor3(gav %between% c(-1L, 1L), , d == 0L))
expect_equal(or3s(gaw %between% c(-1L, 1L), , f == 1L),
bor3(gaw %between% c(-1L, 1L), , f == 1L))
expect_equal(or3s(gax %between% c(-1L, 1L), , v == 9L),
bor3(gax %between% c(-1L, 1L), , v == 9L))
expect_equal(or3s(gay %between% c(-1L, 1L), j %between% c(-1L, 1L), ),
bor3(gay %between% c(-1L, 1L), j %between% c(-1L, 1L), ))
expect_equal(or3s(gaz %between% c(-1L, 1L), o %between% c(-1L, 1L), ),
bor3(gaz %between% c(-1L, 1L), o %between% c(-1L, 1L), ))
expect_equal(or3s(gba %between% c(-1L, 1L), h %between% c(-1L, 1L), ),
bor3(gba %between% c(-1L, 1L), h %between% c(-1L, 1L), ))
expect_equal(or3s(gbb %between% c(-1L, 1L), d %between% c(-1L, 1L), o == 0L),
bor3(gbb %between% c(-1L, 1L), d %between% c(-1L, 1L), o == 0L))
expect_equal(or3s(gbc %between% c(-1L, 1L), w %between% c(-1L, 1L), t == 1L),
bor3(gbc %between% c(-1L, 1L), w %between% c(-1L, 1L), t == 1L))
expect_equal(or3s(gbd %between% c(-1L, 1L), v %between% c(-1L, 1L), p == 9L),
bor3(gbd %between% c(-1L, 1L), v %between% c(-1L, 1L), p == 9L))
expect_equal(or3s(gbe %between% c(-1L, 1L), , ),
bor3(gbe %between% c(-1L, 1L), , ))
expect_equal(or3s(gbf %between% c(-1L, 1L), , ),
bor3(gbf %between% c(-1L, 1L), , ))
expect_equal(or3s(gbg %between% c(-1L, 1L), , ),
bor3(gbg %between% c(-1L, 1L), , ))
expect_equal(or3s(gbh %between% c(-1L, 1L), , k > 0L),
bor3(gbh %between% c(-1L, 1L), , k > 0L))
expect_equal(or3s(gbi %between% c(-1L, 1L), , q > 1L),
bor3(gbi %between% c(-1L, 1L), , q > 1L))
expect_equal(or3s(gbj %between% c(-1L, 1L), , l > 9L),
bor3(gbj %between% c(-1L, 1L), , l > 9L))
expect_equal(or3s(gbk %between% c(-1L, 1L), u %between% c(-1L, 1L), ),
bor3(gbk %between% c(-1L, 1L), u %between% c(-1L, 1L), ))
expect_equal(or3s(gbl %between% c(-1L, 1L), t %between% c(-1L, 1L), ),
bor3(gbl %between% c(-1L, 1L), t %between% c(-1L, 1L), ))
expect_equal(or3s(gbm %between% c(-1L, 1L), e %between% c(-1L, 1L), ),
bor3(gbm %between% c(-1L, 1L), e %between% c(-1L, 1L), ))
expect_equal(or3s(gbn %between% c(-1L, 1L), d %between% c(-1L, 1L), j > 0L),
bor3(gbn %between% c(-1L, 1L), d %between% c(-1L, 1L), j > 0L))
expect_equal(or3s(gbo %between% c(-1L, 1L), l %between% c(-1L, 1L), n > 1L),
bor3(gbo %between% c(-1L, 1L), l %between% c(-1L, 1L), n > 1L))
expect_equal(or3s(gbp %between% c(-1L, 1L), r %between% c(-1L, 1L), y > 9L),
bor3(gbp %between% c(-1L, 1L), r %between% c(-1L, 1L), y > 9L))
expect_equal(or3s(gbq %between% c(-1L, 1L), , ),
bor3(gbq %between% c(-1L, 1L), , ))
expect_equal(or3s(gbr %between% c(-1L, 1L), , ),
bor3(gbr %between% c(-1L, 1L), , ))
expect_equal(or3s(gbs %between% c(-1L, 1L), , ),
bor3(gbs %between% c(-1L, 1L), , ))
expect_equal(or3s(gbt %between% c(-1L, 1L), , d >= 0L),
bor3(gbt %between% c(-1L, 1L), , d >= 0L))
expect_equal(or3s(gbu %between% c(-1L, 1L), , l >= 1L),
bor3(gbu %between% c(-1L, 1L), , l >= 1L))
expect_equal(or3s(gbv %between% c(-1L, 1L), , x >= 9L),
bor3(gbv %between% c(-1L, 1L), , x >= 9L))
expect_equal(or3s(gbw %between% c(-1L, 1L), u %between% c(-1L, 1L), ),
bor3(gbw %between% c(-1L, 1L), u %between% c(-1L, 1L), ))
expect_equal(or3s(gbx %between% c(-1L, 1L), p %between% c(-1L, 1L), ),
bor3(gbx %between% c(-1L, 1L), p %between% c(-1L, 1L), ))
expect_equal(or3s(gby %between% c(-1L, 1L), t %between% c(-1L, 1L), ),
bor3(gby %between% c(-1L, 1L), t %between% c(-1L, 1L), ))
expect_equal(or3s(gbz %between% c(-1L, 1L), p %between% c(-1L, 1L), g >= 0L),
bor3(gbz %between% c(-1L, 1L), p %between% c(-1L, 1L), g >= 0L))
expect_equal(or3s(gca %between% c(-1L, 1L), l %between% c(-1L, 1L), u >= 1L),
bor3(gca %between% c(-1L, 1L), l %between% c(-1L, 1L), u >= 1L))
expect_equal(or3s(gcb %between% c(-1L, 1L), r %between% c(-1L, 1L), a >= 9L),
bor3(gcb %between% c(-1L, 1L), r %between% c(-1L, 1L), a >= 9L))
expect_equal(or3s(gcc %between% c(-1L, 1L), , ),
bor3(gcc %between% c(-1L, 1L), , ))
expect_equal(or3s(gcd %between% c(-1L, 1L), , ),
bor3(gcd %between% c(-1L, 1L), , ))
expect_equal(or3s(gce %between% c(-1L, 1L), , ),
bor3(gce %between% c(-1L, 1L), , ))
expect_equal(or3s(gcf %between% c(-1L, 1L), , logi_z),
bor3(gcf %between% c(-1L, 1L), , logi_z))
expect_equal(or3s(gcg %between% c(-1L, 1L), , logi_q),
bor3(gcg %between% c(-1L, 1L), , logi_q))
expect_equal(or3s(gch %between% c(-1L, 1L), , logi_d),
bor3(gch %between% c(-1L, 1L), , logi_d))
expect_equal(or3s(gci %between% c(-1L, 1L), j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gci %between% c(-1L, 1L), j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gcj %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gcj %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gck %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gck %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gcl %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), logi_h),
bor3(gcl %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), logi_h))
expect_equal(or3s(gcm %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L), logi_i),
bor3(gcm %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L), logi_i))
expect_equal(or3s(gcn %between% c(-1L, 1L), c %in% c(4L, -3L, 2L, 7L, 8L), logi_y),
bor3(gcn %between% c(-1L, 1L), c %in% c(4L, -3L, 2L, 7L, 8L), logi_y))
expect_equal(or3s(gco %between% c(-1L, 1L), , ),
bor3(gco %between% c(-1L, 1L), , ))
expect_equal(or3s(gcp %between% c(-1L, 1L), , ),
bor3(gcp %between% c(-1L, 1L), , ))
expect_equal(or3s(gcq %between% c(-1L, 1L), , ),
bor3(gcq %between% c(-1L, 1L), , ))
expect_equal(or3s(gcr %between% c(-1L, 1L), , logi_q),
bor3(gcr %between% c(-1L, 1L), , logi_q))
expect_equal(or3s(gcs %between% c(-1L, 1L), , logi_a),
bor3(gcs %between% c(-1L, 1L), , logi_a))
expect_equal(or3s(gct %between% c(-1L, 1L), , logi_g),
bor3(gct %between% c(-1L, 1L), , logi_g))
expect_equal(or3s(gcu %between% c(-1L, 1L), d %in% 1:4, ),
bor3(gcu %between% c(-1L, 1L), d %in% 1:4, ))
expect_equal(or3s(gcv %between% c(-1L, 1L), a %in% 1:4, ),
bor3(gcv %between% c(-1L, 1L), a %in% 1:4, ))
expect_equal(or3s(gcw %between% c(-1L, 1L), a %in% 1:4, ),
bor3(gcw %between% c(-1L, 1L), a %in% 1:4, ))
expect_equal(or3s(gcx %between% c(-1L, 1L), i %in% 1:4, logi_n),
bor3(gcx %between% c(-1L, 1L), i %in% 1:4, logi_n))
expect_equal(or3s(gcy %between% c(-1L, 1L), y %in% 1:4, logi_u),
bor3(gcy %between% c(-1L, 1L), y %in% 1:4, logi_u))
expect_equal(or3s(gcz %between% c(-1L, 1L), z %in% 1:4, logi_g),
bor3(gcz %between% c(-1L, 1L), z %in% 1:4, logi_g))
expect_equal(or3s(gda %between% c(-1L, 1L), , ),
bor3(gda %between% c(-1L, 1L), , ))
expect_equal(or3s(gdb %between% c(-1L, 1L), , ),
bor3(gdb %between% c(-1L, 1L), , ))
expect_equal(or3s(gdc %between% c(-1L, 1L), , ),
bor3(gdc %between% c(-1L, 1L), , ))
expect_equal(or3s(gdd %between% c(-1L, 1L), , !logi_m),
bor3(gdd %between% c(-1L, 1L), , !logi_m))
expect_equal(or3s(gde %between% c(-1L, 1L), , !logi_n),
bor3(gde %between% c(-1L, 1L), , !logi_n))
expect_equal(or3s(gdf %between% c(-1L, 1L), , !logi_c),
bor3(gdf %between% c(-1L, 1L), , !logi_c))
expect_equal(or3s(gdg %between% c(-1L, 1L), i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gdg %between% c(-1L, 1L), i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gdh %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gdh %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gdi %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gdi %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gdj %between% c(-1L, 1L), q %in% c(4L, -3L, 2L, 7L, 8L), !logi_j),
bor3(gdj %between% c(-1L, 1L), q %in% c(4L, -3L, 2L, 7L, 8L), !logi_j))
expect_equal(or3s(gdk %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L), !logi_c),
bor3(gdk %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L), !logi_c))
expect_equal(or3s(gdl %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), !logi_e),
bor3(gdl %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), !logi_e))
expect_equal(or3s(gdm %between% c(-1L, 1L), , ),
bor3(gdm %between% c(-1L, 1L), , ))
expect_equal(or3s(gdn %between% c(-1L, 1L), , ),
bor3(gdn %between% c(-1L, 1L), , ))
expect_equal(or3s(gdo %between% c(-1L, 1L), , ),
bor3(gdo %between% c(-1L, 1L), , ))
expect_equal(or3s(gdp %between% c(-1L, 1L), , !logi_u),
bor3(gdp %between% c(-1L, 1L), , !logi_u))
expect_equal(or3s(gdq %between% c(-1L, 1L), , !logi_v),
bor3(gdq %between% c(-1L, 1L), , !logi_v))
expect_equal(or3s(gdr %between% c(-1L, 1L), , !logi_n),
bor3(gdr %between% c(-1L, 1L), , !logi_n))
expect_equal(or3s(gds %between% c(-1L, 1L), s %in% 1:4, ),
bor3(gds %between% c(-1L, 1L), s %in% 1:4, ))
expect_equal(or3s(gdt %between% c(-1L, 1L), k %in% 1:4, ),
bor3(gdt %between% c(-1L, 1L), k %in% 1:4, ))
expect_equal(or3s(gdu %between% c(-1L, 1L), j %in% 1:4, ),
bor3(gdu %between% c(-1L, 1L), j %in% 1:4, ))
expect_equal(or3s(gdv %between% c(-1L, 1L), e %in% 1:4, !logi_r),
bor3(gdv %between% c(-1L, 1L), e %in% 1:4, !logi_r))
expect_equal(or3s(gdw %between% c(-1L, 1L), u %in% 1:4, !logi_o),
bor3(gdw %between% c(-1L, 1L), u %in% 1:4, !logi_o))
expect_equal(or3s(gdx %between% c(-1L, 1L), a %in% 1:4, !logi_k),
bor3(gdx %between% c(-1L, 1L), a %in% 1:4, !logi_k))
expect_equal(or3s(gdy %between% c(-1L, 1L), , ),
bor3(gdy %between% c(-1L, 1L), , ))
expect_equal(or3s(gdz %between% c(-1L, 1L), , ),
bor3(gdz %between% c(-1L, 1L), , ))
expect_equal(or3s(gea %between% c(-1L, 1L), , ),
bor3(gea %between% c(-1L, 1L), , ))
expect_equal(or3s(geb %between% c(-1L, 1L), , k != 0L),
bor3(geb %between% c(-1L, 1L), , k != 0L))
expect_equal(or3s(gec %between% c(-1L, 1L), , h != 1L),
bor3(gec %between% c(-1L, 1L), , h != 1L))
expect_equal(or3s(ged %between% c(-1L, 1L), , x != 9L),
bor3(ged %between% c(-1L, 1L), , x != 9L))
expect_equal(or3s(gee %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gee %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gef %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gef %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(geg %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(geg %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(geh %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), l != 0L),
bor3(geh %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), l != 0L))
expect_equal(or3s(gei %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L), e != 1L),
bor3(gei %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L), e != 1L))
expect_equal(or3s(gej %between% c(-1L, 1L), g %in% c(4L, -3L, 2L, 7L, 8L), i != 9L),
bor3(gej %between% c(-1L, 1L), g %in% c(4L, -3L, 2L, 7L, 8L), i != 9L))
expect_equal(or3s(gek %between% c(-1L, 1L), , ),
bor3(gek %between% c(-1L, 1L), , ))
expect_equal(or3s(gel %between% c(-1L, 1L), , ),
bor3(gel %between% c(-1L, 1L), , ))
expect_equal(or3s(gem %between% c(-1L, 1L), , ),
bor3(gem %between% c(-1L, 1L), , ))
expect_equal(or3s(gen %between% c(-1L, 1L), , a != 0L),
bor3(gen %between% c(-1L, 1L), , a != 0L))
expect_equal(or3s(geo %between% c(-1L, 1L), , m != 1L),
bor3(geo %between% c(-1L, 1L), , m != 1L))
expect_equal(or3s(gep %between% c(-1L, 1L), , r != 9L),
bor3(gep %between% c(-1L, 1L), , r != 9L))
expect_equal(or3s(geq %between% c(-1L, 1L), e %in% 1:4, ),
bor3(geq %between% c(-1L, 1L), e %in% 1:4, ))
expect_equal(or3s(ger %between% c(-1L, 1L), l %in% 1:4, ),
bor3(ger %between% c(-1L, 1L), l %in% 1:4, ))
expect_equal(or3s(ges %between% c(-1L, 1L), q %in% 1:4, ),
bor3(ges %between% c(-1L, 1L), q %in% 1:4, ))
expect_equal(or3s(get %between% c(-1L, 1L), q %in% 1:4, s != 0L),
bor3(get %between% c(-1L, 1L), q %in% 1:4, s != 0L))
expect_equal(or3s(geu %between% c(-1L, 1L), k %in% 1:4, q != 1L),
bor3(geu %between% c(-1L, 1L), k %in% 1:4, q != 1L))
expect_equal(or3s(gev %between% c(-1L, 1L), s %in% 1:4, w != 9L),
bor3(gev %between% c(-1L, 1L), s %in% 1:4, w != 9L))
expect_equal(or3s(gew %between% c(-1L, 1L), , ),
bor3(gew %between% c(-1L, 1L), , ))
expect_equal(or3s(gex %between% c(-1L, 1L), , ),
bor3(gex %between% c(-1L, 1L), , ))
expect_equal(or3s(gey %between% c(-1L, 1L), , ),
bor3(gey %between% c(-1L, 1L), , ))
expect_equal(or3s(gez %between% c(-1L, 1L), , z %between% c(-1L, 1L)),
bor3(gez %between% c(-1L, 1L), , z %between% c(-1L, 1L)))
expect_equal(or3s(gfa %between% c(-1L, 1L), , z %between% c(-1L, 1L)),
bor3(gfa %between% c(-1L, 1L), , z %between% c(-1L, 1L)))
expect_equal(or3s(gfb %between% c(-1L, 1L), , r %between% c(-1L, 1L)),
bor3(gfb %between% c(-1L, 1L), , r %between% c(-1L, 1L)))
expect_equal(or3s(gfc %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gfc %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gfd %between% c(-1L, 1L), u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gfd %between% c(-1L, 1L), u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gfe %between% c(-1L, 1L), c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gfe %between% c(-1L, 1L), c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gff %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), x %between% c(-1L, 1L)),
bor3(gff %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), x %between% c(-1L, 1L)))
expect_equal(or3s(gfg %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L)),
bor3(gfg %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L)))
expect_equal(or3s(gfh %between% c(-1L, 1L), k %in% c(4L, -3L, 2L, 7L, 8L), p %between% c(-1L, 1L)),
bor3(gfh %between% c(-1L, 1L), k %in% c(4L, -3L, 2L, 7L, 8L), p %between% c(-1L, 1L)))
expect_equal(or3s(gfi %between% c(-1L, 1L), , ),
bor3(gfi %between% c(-1L, 1L), , ))
expect_equal(or3s(gfj %between% c(-1L, 1L), , ),
bor3(gfj %between% c(-1L, 1L), , ))
expect_equal(or3s(gfk %between% c(-1L, 1L), , ),
bor3(gfk %between% c(-1L, 1L), , ))
expect_equal(or3s(gfl %between% c(-1L, 1L), , n %between% c(-1L, 1L)),
bor3(gfl %between% c(-1L, 1L), , n %between% c(-1L, 1L)))
expect_equal(or3s(gfm %between% c(-1L, 1L), , r %between% c(-1L, 1L)),
bor3(gfm %between% c(-1L, 1L), , r %between% c(-1L, 1L)))
expect_equal(or3s(gfn %between% c(-1L, 1L), , t %between% c(-1L, 1L)),
bor3(gfn %between% c(-1L, 1L), , t %between% c(-1L, 1L)))
expect_equal(or3s(gfo %between% c(-1L, 1L), j %in% 1:4, ),
bor3(gfo %between% c(-1L, 1L), j %in% 1:4, ))
expect_equal(or3s(gfp %between% c(-1L, 1L), j %in% 1:4, ),
bor3(gfp %between% c(-1L, 1L), j %in% 1:4, ))
expect_equal(or3s(gfq %between% c(-1L, 1L), m %in% 1:4, ),
bor3(gfq %between% c(-1L, 1L), m %in% 1:4, ))
expect_equal(or3s(gfr %between% c(-1L, 1L), q %in% 1:4, x %between% c(-1L, 1L)),
bor3(gfr %between% c(-1L, 1L), q %in% 1:4, x %between% c(-1L, 1L)))
expect_equal(or3s(gfs %between% c(-1L, 1L), m %in% 1:4, p %between% c(-1L, 1L)),
bor3(gfs %between% c(-1L, 1L), m %in% 1:4, p %between% c(-1L, 1L)))
expect_equal(or3s(gft %between% c(-1L, 1L), x %in% 1:4, j %between% c(-1L, 1L)),
bor3(gft %between% c(-1L, 1L), x %in% 1:4, j %between% c(-1L, 1L)))
expect_equal(or3s(gfu %between% c(-1L, 1L), , ),
bor3(gfu %between% c(-1L, 1L), , ))
expect_equal(or3s(gfv %between% c(-1L, 1L), , ),
bor3(gfv %between% c(-1L, 1L), , ))
expect_equal(or3s(gfw %between% c(-1L, 1L), , ),
bor3(gfw %between% c(-1L, 1L), , ))
expect_equal(or3s(gfx %between% c(-1L, 1L), , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gfx %between% c(-1L, 1L), , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gfy %between% c(-1L, 1L), , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gfy %between% c(-1L, 1L), , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gfz %between% c(-1L, 1L), , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gfz %between% c(-1L, 1L), , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gga %between% c(-1L, 1L), r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gga %between% c(-1L, 1L), r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ggb %between% c(-1L, 1L), j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ggb %between% c(-1L, 1L), j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ggc %between% c(-1L, 1L), d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ggc %between% c(-1L, 1L), d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ggd %between% c(-1L, 1L), q %in% c(4L, -3L, 2L, 7L, 8L), j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ggd %between% c(-1L, 1L), q %in% c(4L, -3L, 2L, 7L, 8L), j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gge %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gge %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ggf %between% c(-1L, 1L), g %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ggf %between% c(-1L, 1L), g %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ggg %between% c(-1L, 1L), , ),
bor3(ggg %between% c(-1L, 1L), , ))
expect_equal(or3s(ggh %between% c(-1L, 1L), , ),
bor3(ggh %between% c(-1L, 1L), , ))
expect_equal(or3s(ggi %between% c(-1L, 1L), , ),
bor3(ggi %between% c(-1L, 1L), , ))
expect_equal(or3s(ggj %between% c(-1L, 1L), , b %in% 1:4),
bor3(ggj %between% c(-1L, 1L), , b %in% 1:4))
expect_equal(or3s(ggk %between% c(-1L, 1L), , s %in% 1:4),
bor3(ggk %between% c(-1L, 1L), , s %in% 1:4))
expect_equal(or3s(ggl %between% c(-1L, 1L), , f %in% 1:4),
bor3(ggl %between% c(-1L, 1L), , f %in% 1:4))
expect_equal(or3s(ggm %between% c(-1L, 1L), n %in% 1:4, ),
bor3(ggm %between% c(-1L, 1L), n %in% 1:4, ))
expect_equal(or3s(ggn %between% c(-1L, 1L), u %in% 1:4, ),
bor3(ggn %between% c(-1L, 1L), u %in% 1:4, ))
expect_equal(or3s(ggo %between% c(-1L, 1L), x %in% 1:4, ),
bor3(ggo %between% c(-1L, 1L), x %in% 1:4, ))
expect_equal(or3s(ggp %between% c(-1L, 1L), x %in% 1:4, c %in% 1:4),
bor3(ggp %between% c(-1L, 1L), x %in% 1:4, c %in% 1:4))
expect_equal(or3s(ggq %between% c(-1L, 1L), t %in% 1:4, n %in% 1:4),
bor3(ggq %between% c(-1L, 1L), t %in% 1:4, n %in% 1:4))
expect_equal(or3s(ggr %between% c(-1L, 1L), c %in% 1:4, y %in% 1:4),
bor3(ggr %between% c(-1L, 1L), c %in% 1:4, y %in% 1:4))
expect_equal(or3s(ggs %between% c(-1L, 1L), , ),
bor3(ggs %between% c(-1L, 1L), , ))
expect_equal(or3s(ggt %between% c(-1L, 1L), , ),
bor3(ggt %between% c(-1L, 1L), , ))
expect_equal(or3s(ggu %between% c(-1L, 1L), , ),
bor3(ggu %between% c(-1L, 1L), , ))
expect_equal(or3s(ggv %between% c(-1L, 1L), , o < 0L),
bor3(ggv %between% c(-1L, 1L), , o < 0L))
expect_equal(or3s(ggw %between% c(-1L, 1L), , a < 1L),
bor3(ggw %between% c(-1L, 1L), , a < 1L))
expect_equal(or3s(ggx %between% c(-1L, 1L), , j < 9L),
bor3(ggx %between% c(-1L, 1L), , j < 9L))
expect_equal(or3s(ggy %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ggy %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ggz %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ggz %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gha %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gha %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ghb %between% c(-1L, 1L), f %in% c(4L, -3L, 2L, 7L, 8L), g < 0L),
bor3(ghb %between% c(-1L, 1L), f %in% c(4L, -3L, 2L, 7L, 8L), g < 0L))
expect_equal(or3s(ghc %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), d < 1L),
bor3(ghc %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), d < 1L))
expect_equal(or3s(ghd %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L), d < 9L),
bor3(ghd %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L), d < 9L))
expect_equal(or3s(ghe %between% c(-1L, 1L), , ),
bor3(ghe %between% c(-1L, 1L), , ))
expect_equal(or3s(ghf %between% c(-1L, 1L), , ),
bor3(ghf %between% c(-1L, 1L), , ))
expect_equal(or3s(ghg %between% c(-1L, 1L), , ),
bor3(ghg %between% c(-1L, 1L), , ))
expect_equal(or3s(ghh %between% c(-1L, 1L), , a < 0L),
bor3(ghh %between% c(-1L, 1L), , a < 0L))
expect_equal(or3s(ghi %between% c(-1L, 1L), , v < 1L),
bor3(ghi %between% c(-1L, 1L), , v < 1L))
expect_equal(or3s(ghj %between% c(-1L, 1L), , w < 9L),
bor3(ghj %between% c(-1L, 1L), , w < 9L))
expect_equal(or3s(ghk %between% c(-1L, 1L), s %in% 1:4, ),
bor3(ghk %between% c(-1L, 1L), s %in% 1:4, ))
expect_equal(or3s(ghl %between% c(-1L, 1L), w %in% 1:4, ),
bor3(ghl %between% c(-1L, 1L), w %in% 1:4, ))
expect_equal(or3s(ghm %between% c(-1L, 1L), r %in% 1:4, ),
bor3(ghm %between% c(-1L, 1L), r %in% 1:4, ))
expect_equal(or3s(ghn %between% c(-1L, 1L), t %in% 1:4, j < 0L),
bor3(ghn %between% c(-1L, 1L), t %in% 1:4, j < 0L))
expect_equal(or3s(gho %between% c(-1L, 1L), w %in% 1:4, o < 1L),
bor3(gho %between% c(-1L, 1L), w %in% 1:4, o < 1L))
expect_equal(or3s(ghp %between% c(-1L, 1L), x %in% 1:4, f < 9L),
bor3(ghp %between% c(-1L, 1L), x %in% 1:4, f < 9L))
expect_equal(or3s(ghq %between% c(-1L, 1L), , ),
bor3(ghq %between% c(-1L, 1L), , ))
expect_equal(or3s(ghr %between% c(-1L, 1L), , ),
bor3(ghr %between% c(-1L, 1L), , ))
expect_equal(or3s(ghs %between% c(-1L, 1L), , ),
bor3(ghs %between% c(-1L, 1L), , ))
expect_equal(or3s(ght %between% c(-1L, 1L), , g <= 0L),
bor3(ght %between% c(-1L, 1L), , g <= 0L))
expect_equal(or3s(ghu %between% c(-1L, 1L), , r <= 1L),
bor3(ghu %between% c(-1L, 1L), , r <= 1L))
expect_equal(or3s(ghv %between% c(-1L, 1L), , b <= 9L),
bor3(ghv %between% c(-1L, 1L), , b <= 9L))
expect_equal(or3s(ghw %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ghw %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ghx %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ghx %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ghy %between% c(-1L, 1L), k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ghy %between% c(-1L, 1L), k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ghz %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), b <= 0L),
bor3(ghz %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), b <= 0L))
expect_equal(or3s(gia %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), b <= 1L),
bor3(gia %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), b <= 1L))
expect_equal(or3s(gib %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L), d <= 9L),
bor3(gib %between% c(-1L, 1L), m %in% c(4L, -3L, 2L, 7L, 8L), d <= 9L))
expect_equal(or3s(gic %between% c(-1L, 1L), , ),
bor3(gic %between% c(-1L, 1L), , ))
expect_equal(or3s(gid %between% c(-1L, 1L), , ),
bor3(gid %between% c(-1L, 1L), , ))
expect_equal(or3s(gie %between% c(-1L, 1L), , ),
bor3(gie %between% c(-1L, 1L), , ))
expect_equal(or3s(gif %between% c(-1L, 1L), , w <= 0L),
bor3(gif %between% c(-1L, 1L), , w <= 0L))
expect_equal(or3s(gig %between% c(-1L, 1L), , o <= 1L),
bor3(gig %between% c(-1L, 1L), , o <= 1L))
expect_equal(or3s(gih %between% c(-1L, 1L), , d <= 9L),
bor3(gih %between% c(-1L, 1L), , d <= 9L))
expect_equal(or3s(gii %between% c(-1L, 1L), l %in% 1:4, ),
bor3(gii %between% c(-1L, 1L), l %in% 1:4, ))
expect_equal(or3s(gij %between% c(-1L, 1L), p %in% 1:4, ),
bor3(gij %between% c(-1L, 1L), p %in% 1:4, ))
expect_equal(or3s(gik %between% c(-1L, 1L), k %in% 1:4, ),
bor3(gik %between% c(-1L, 1L), k %in% 1:4, ))
expect_equal(or3s(gil %between% c(-1L, 1L), h %in% 1:4, s <= 0L),
bor3(gil %between% c(-1L, 1L), h %in% 1:4, s <= 0L))
expect_equal(or3s(gim %between% c(-1L, 1L), j %in% 1:4, t <= 1L),
bor3(gim %between% c(-1L, 1L), j %in% 1:4, t <= 1L))
expect_equal(or3s(gin %between% c(-1L, 1L), p %in% 1:4, b <= 9L),
bor3(gin %between% c(-1L, 1L), p %in% 1:4, b <= 9L))
expect_equal(or3s(gio %between% c(-1L, 1L), , ),
bor3(gio %between% c(-1L, 1L), , ))
expect_equal(or3s(gip %between% c(-1L, 1L), , ),
bor3(gip %between% c(-1L, 1L), , ))
expect_equal(or3s(giq %between% c(-1L, 1L), , ),
bor3(giq %between% c(-1L, 1L), , ))
expect_equal(or3s(gir %between% c(-1L, 1L), , v == 0L),
bor3(gir %between% c(-1L, 1L), , v == 0L))
expect_equal(or3s(gis %between% c(-1L, 1L), , b == 1L),
bor3(gis %between% c(-1L, 1L), , b == 1L))
expect_equal(or3s(git %between% c(-1L, 1L), , f == 9L),
bor3(git %between% c(-1L, 1L), , f == 9L))
expect_equal(or3s(giu %between% c(-1L, 1L), f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(giu %between% c(-1L, 1L), f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(giv %between% c(-1L, 1L), v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(giv %between% c(-1L, 1L), v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(giw %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(giw %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gix %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), u == 0L),
bor3(gix %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), u == 0L))
expect_equal(or3s(giy %between% c(-1L, 1L), f %in% c(4L, -3L, 2L, 7L, 8L), m == 1L),
bor3(giy %between% c(-1L, 1L), f %in% c(4L, -3L, 2L, 7L, 8L), m == 1L))
expect_equal(or3s(giz %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L), a == 9L),
bor3(giz %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L), a == 9L))
expect_equal(or3s(gja %between% c(-1L, 1L), , ),
bor3(gja %between% c(-1L, 1L), , ))
expect_equal(or3s(gjb %between% c(-1L, 1L), , ),
bor3(gjb %between% c(-1L, 1L), , ))
expect_equal(or3s(gjc %between% c(-1L, 1L), , ),
bor3(gjc %between% c(-1L, 1L), , ))
expect_equal(or3s(gjd %between% c(-1L, 1L), , r == 0L),
bor3(gjd %between% c(-1L, 1L), , r == 0L))
expect_equal(or3s(gje %between% c(-1L, 1L), , n == 1L),
bor3(gje %between% c(-1L, 1L), , n == 1L))
expect_equal(or3s(gjf %between% c(-1L, 1L), , c == 9L),
bor3(gjf %between% c(-1L, 1L), , c == 9L))
expect_equal(or3s(gjg %between% c(-1L, 1L), f %in% 1:4, ),
bor3(gjg %between% c(-1L, 1L), f %in% 1:4, ))
expect_equal(or3s(gjh %between% c(-1L, 1L), h %in% 1:4, ),
bor3(gjh %between% c(-1L, 1L), h %in% 1:4, ))
expect_equal(or3s(gji %between% c(-1L, 1L), n %in% 1:4, ),
bor3(gji %between% c(-1L, 1L), n %in% 1:4, ))
expect_equal(or3s(gjj %between% c(-1L, 1L), r %in% 1:4, g == 0L),
bor3(gjj %between% c(-1L, 1L), r %in% 1:4, g == 0L))
expect_equal(or3s(gjk %between% c(-1L, 1L), m %in% 1:4, i == 1L),
bor3(gjk %between% c(-1L, 1L), m %in% 1:4, i == 1L))
expect_equal(or3s(gjl %between% c(-1L, 1L), t %in% 1:4, e == 9L),
bor3(gjl %between% c(-1L, 1L), t %in% 1:4, e == 9L))
expect_equal(or3s(gjm %between% c(-1L, 1L), , ),
bor3(gjm %between% c(-1L, 1L), , ))
expect_equal(or3s(gjn %between% c(-1L, 1L), , ),
bor3(gjn %between% c(-1L, 1L), , ))
expect_equal(or3s(gjo %between% c(-1L, 1L), , ),
bor3(gjo %between% c(-1L, 1L), , ))
expect_equal(or3s(gjp %between% c(-1L, 1L), , v > 0L),
bor3(gjp %between% c(-1L, 1L), , v > 0L))
expect_equal(or3s(gjq %between% c(-1L, 1L), , l > 1L),
bor3(gjq %between% c(-1L, 1L), , l > 1L))
expect_equal(or3s(gjr %between% c(-1L, 1L), , u > 9L),
bor3(gjr %between% c(-1L, 1L), , u > 9L))
expect_equal(or3s(gjs %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gjs %between% c(-1L, 1L), z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gjt %between% c(-1L, 1L), i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gjt %between% c(-1L, 1L), i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gju %between% c(-1L, 1L), x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gju %between% c(-1L, 1L), x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gjv %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), v > 0L),
bor3(gjv %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), v > 0L))
expect_equal(or3s(gjw %between% c(-1L, 1L), e %in% c(4L, -3L, 2L, 7L, 8L), e > 1L),
bor3(gjw %between% c(-1L, 1L), e %in% c(4L, -3L, 2L, 7L, 8L), e > 1L))
expect_equal(or3s(gjx %between% c(-1L, 1L), d %in% c(4L, -3L, 2L, 7L, 8L), n > 9L),
bor3(gjx %between% c(-1L, 1L), d %in% c(4L, -3L, 2L, 7L, 8L), n > 9L))
expect_equal(or3s(gjy %between% c(-1L, 1L), , ),
bor3(gjy %between% c(-1L, 1L), , ))
expect_equal(or3s(gjz %between% c(-1L, 1L), , ),
bor3(gjz %between% c(-1L, 1L), , ))
expect_equal(or3s(gka %between% c(-1L, 1L), , ),
bor3(gka %between% c(-1L, 1L), , ))
expect_equal(or3s(gkb %between% c(-1L, 1L), , c > 0L),
bor3(gkb %between% c(-1L, 1L), , c > 0L))
expect_equal(or3s(gkc %between% c(-1L, 1L), , j > 1L),
bor3(gkc %between% c(-1L, 1L), , j > 1L))
expect_equal(or3s(gkd %between% c(-1L, 1L), , s > 9L),
bor3(gkd %between% c(-1L, 1L), , s > 9L))
expect_equal(or3s(gke %between% c(-1L, 1L), d %in% 1:4, ),
bor3(gke %between% c(-1L, 1L), d %in% 1:4, ))
expect_equal(or3s(gkf %between% c(-1L, 1L), t %in% 1:4, ),
bor3(gkf %between% c(-1L, 1L), t %in% 1:4, ))
expect_equal(or3s(gkg %between% c(-1L, 1L), k %in% 1:4, ),
bor3(gkg %between% c(-1L, 1L), k %in% 1:4, ))
expect_equal(or3s(gkh %between% c(-1L, 1L), t %in% 1:4, g > 0L),
bor3(gkh %between% c(-1L, 1L), t %in% 1:4, g > 0L))
expect_equal(or3s(gki %between% c(-1L, 1L), z %in% 1:4, n > 1L),
bor3(gki %between% c(-1L, 1L), z %in% 1:4, n > 1L))
expect_equal(or3s(gkj %between% c(-1L, 1L), p %in% 1:4, w > 9L),
bor3(gkj %between% c(-1L, 1L), p %in% 1:4, w > 9L))
expect_equal(or3s(gkk %between% c(-1L, 1L), , ),
bor3(gkk %between% c(-1L, 1L), , ))
expect_equal(or3s(gkl %between% c(-1L, 1L), , ),
bor3(gkl %between% c(-1L, 1L), , ))
expect_equal(or3s(gkm %between% c(-1L, 1L), , ),
bor3(gkm %between% c(-1L, 1L), , ))
expect_equal(or3s(gkn %between% c(-1L, 1L), , x >= 0L),
bor3(gkn %between% c(-1L, 1L), , x >= 0L))
expect_equal(or3s(gko %between% c(-1L, 1L), , c >= 1L),
bor3(gko %between% c(-1L, 1L), , c >= 1L))
expect_equal(or3s(gkp %between% c(-1L, 1L), , x >= 9L),
bor3(gkp %between% c(-1L, 1L), , x >= 9L))
expect_equal(or3s(gkq %between% c(-1L, 1L), r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gkq %between% c(-1L, 1L), r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gkr %between% c(-1L, 1L), v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gkr %between% c(-1L, 1L), v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gks %between% c(-1L, 1L), o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(gks %between% c(-1L, 1L), o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(gkt %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), r >= 0L),
bor3(gkt %between% c(-1L, 1L), y %in% c(4L, -3L, 2L, 7L, 8L), r >= 0L))
expect_equal(or3s(gku %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), x >= 1L),
bor3(gku %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L), x >= 1L))
expect_equal(or3s(gkv %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), f >= 9L),
bor3(gkv %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L), f >= 9L))
expect_equal(or3s(gkw %between% c(-1L, 1L), , ),
bor3(gkw %between% c(-1L, 1L), , ))
expect_equal(or3s(gkx %between% c(-1L, 1L), , ),
bor3(gkx %between% c(-1L, 1L), , ))
expect_equal(or3s(gky %between% c(-1L, 1L), , ),
bor3(gky %between% c(-1L, 1L), , ))
expect_equal(or3s(gkz %between% c(-1L, 1L), , j >= 0L),
bor3(gkz %between% c(-1L, 1L), , j >= 0L))
expect_equal(or3s(gla %between% c(-1L, 1L), , r >= 1L),
bor3(gla %between% c(-1L, 1L), , r >= 1L))
expect_equal(or3s(glb %between% c(-1L, 1L), , h >= 9L),
bor3(glb %between% c(-1L, 1L), , h >= 9L))
expect_equal(or3s(glc %between% c(-1L, 1L), m %in% 1:4, ),
bor3(glc %between% c(-1L, 1L), m %in% 1:4, ))
expect_equal(or3s(gld %between% c(-1L, 1L), o %in% 1:4, ),
bor3(gld %between% c(-1L, 1L), o %in% 1:4, ))
expect_equal(or3s(gle %between% c(-1L, 1L), x %in% 1:4, ),
bor3(gle %between% c(-1L, 1L), x %in% 1:4, ))
expect_equal(or3s(glf %between% c(-1L, 1L), d %in% 1:4, r >= 0L),
bor3(glf %between% c(-1L, 1L), d %in% 1:4, r >= 0L))
expect_equal(or3s(glg %between% c(-1L, 1L), z %in% 1:4, p >= 1L),
bor3(glg %between% c(-1L, 1L), z %in% 1:4, p >= 1L))
expect_equal(or3s(glh %between% c(-1L, 1L), f %in% 1:4, a >= 9L),
bor3(glh %between% c(-1L, 1L), f %in% 1:4, a >= 9L))
expect_equal(or3s(gli %between% c(-1L, 1L), , ),
bor3(gli %between% c(-1L, 1L), , ))
expect_equal(or3s(glj %between% c(-1L, 1L), , ),
bor3(glj %between% c(-1L, 1L), , ))
expect_equal(or3s(glk %between% c(-1L, 1L), , ),
bor3(glk %between% c(-1L, 1L), , ))
expect_equal(or3s(gll %between% c(-1L, 1L), , logi_f),
bor3(gll %between% c(-1L, 1L), , logi_f))
expect_equal(or3s(glm %between% c(-1L, 1L), , logi_s),
bor3(glm %between% c(-1L, 1L), , logi_s))
expect_equal(or3s(gln %between% c(-1L, 1L), , logi_s),
bor3(gln %between% c(-1L, 1L), , logi_s))
expect_equal(or3s(glo %between% c(-1L, 1L), b < 0L, ),
bor3(glo %between% c(-1L, 1L), b < 0L, ))
expect_equal(or3s(glp %between% c(-1L, 1L), l < 1L, ),
bor3(glp %between% c(-1L, 1L), l < 1L, ))
expect_equal(or3s(glq %between% c(-1L, 1L), e < 9L, ),
bor3(glq %between% c(-1L, 1L), e < 9L, ))
expect_equal(or3s(glr %between% c(-1L, 1L), c < 0L, logi_d),
bor3(glr %between% c(-1L, 1L), c < 0L, logi_d))
expect_equal(or3s(gls %between% c(-1L, 1L), n < 1L, logi_x),
bor3(gls %between% c(-1L, 1L), n < 1L, logi_x))
expect_equal(or3s(glt %between% c(-1L, 1L), s < 9L, logi_k),
bor3(glt %between% c(-1L, 1L), s < 9L, logi_k))
expect_equal(or3s(glu %between% c(-1L, 1L), , ),
bor3(glu %between% c(-1L, 1L), , ))
expect_equal(or3s(glv %between% c(-1L, 1L), , ),
bor3(glv %between% c(-1L, 1L), , ))
expect_equal(or3s(glw %between% c(-1L, 1L), , ),
bor3(glw %between% c(-1L, 1L), , ))
expect_equal(or3s(glx %between% c(-1L, 1L), , !logi_c),
bor3(glx %between% c(-1L, 1L), , !logi_c))
expect_equal(or3s(gly %between% c(-1L, 1L), , !logi_w),
bor3(gly %between% c(-1L, 1L), , !logi_w))
expect_equal(or3s(glz %between% c(-1L, 1L), , !logi_a),
bor3(glz %between% c(-1L, 1L), , !logi_a))
expect_equal(or3s(gma %between% c(-1L, 1L), o < 0L, ),
bor3(gma %between% c(-1L, 1L), o < 0L, ))
expect_equal(or3s(gmb %between% c(-1L, 1L), u < 1L, ),
bor3(gmb %between% c(-1L, 1L), u < 1L, ))
expect_equal(or3s(gmc %between% c(-1L, 1L), p < 9L, ),
bor3(gmc %between% c(-1L, 1L), p < 9L, ))
expect_equal(or3s(gmd %between% c(-1L, 1L), v < 0L, !logi_u),
bor3(gmd %between% c(-1L, 1L), v < 0L, !logi_u))
expect_equal(or3s(gme %between% c(-1L, 1L), v < 1L, !logi_e),
bor3(gme %between% c(-1L, 1L), v < 1L, !logi_e))
expect_equal(or3s(gmf %between% c(-1L, 1L), s < 9L, !logi_r),
bor3(gmf %between% c(-1L, 1L), s < 9L, !logi_r))
expect_equal(or3s(gmg %between% c(-1L, 1L), , ),
bor3(gmg %between% c(-1L, 1L), , ))
expect_equal(or3s(gmh %between% c(-1L, 1L), , ),
bor3(gmh %between% c(-1L, 1L), , ))
expect_equal(or3s(gmi %between% c(-1L, 1L), , ),
bor3(gmi %between% c(-1L, 1L), , ))
expect_equal(or3s(gmj %between% c(-1L, 1L), , o != 0L),
bor3(gmj %between% c(-1L, 1L), , o != 0L))
expect_equal(or3s(gmk %between% c(-1L, 1L), , b != 1L),
bor3(gmk %between% c(-1L, 1L), , b != 1L))
expect_equal(or3s(gml %between% c(-1L, 1L), , m != 9L),
bor3(gml %between% c(-1L, 1L), , m != 9L))
expect_equal(or3s(gmm %between% c(-1L, 1L), o < 0L, ),
bor3(gmm %between% c(-1L, 1L), o < 0L, ))
expect_equal(or3s(gmn %between% c(-1L, 1L), j < 1L, ),
bor3(gmn %between% c(-1L, 1L), j < 1L, ))
expect_equal(or3s(gmo %between% c(-1L, 1L), o < 9L, ),
bor3(gmo %between% c(-1L, 1L), o < 9L, ))
expect_equal(or3s(gmp %between% c(-1L, 1L), w < 0L, x != 0L),
bor3(gmp %between% c(-1L, 1L), w < 0L, x != 0L))
expect_equal(or3s(gmq %between% c(-1L, 1L), h < 1L, u != 1L),
bor3(gmq %between% c(-1L, 1L), h < 1L, u != 1L))
expect_equal(or3s(gmr %between% c(-1L, 1L), c < 9L, c != 9L),
bor3(gmr %between% c(-1L, 1L), c < 9L, c != 9L))
expect_equal(or3s(gms %between% c(-1L, 1L), , ),
bor3(gms %between% c(-1L, 1L), , ))
expect_equal(or3s(gmt %between% c(-1L, 1L), , ),
bor3(gmt %between% c(-1L, 1L), , ))
expect_equal(or3s(gmu %between% c(-1L, 1L), , ),
bor3(gmu %between% c(-1L, 1L), , ))
expect_equal(or3s(gmv %between% c(-1L, 1L), , d %between% c(-1L, 1L)),
bor3(gmv %between% c(-1L, 1L), , d %between% c(-1L, 1L)))
expect_equal(or3s(gmw %between% c(-1L, 1L), , b %between% c(-1L, 1L)),
bor3(gmw %between% c(-1L, 1L), , b %between% c(-1L, 1L)))
expect_equal(or3s(gmx %between% c(-1L, 1L), , l %between% c(-1L, 1L)),
bor3(gmx %between% c(-1L, 1L), , l %between% c(-1L, 1L)))
expect_equal(or3s(gmy %between% c(-1L, 1L), o < 0L, ),
bor3(gmy %between% c(-1L, 1L), o < 0L, ))
expect_equal(or3s(gmz %between% c(-1L, 1L), w < 1L, ),
bor3(gmz %between% c(-1L, 1L), w < 1L, ))
expect_equal(or3s(gna %between% c(-1L, 1L), u < 9L, ),
bor3(gna %between% c(-1L, 1L), u < 9L, ))
expect_equal(or3s(gnb %between% c(-1L, 1L), x < 0L, b %between% c(-1L, 1L)),
bor3(gnb %between% c(-1L, 1L), x < 0L, b %between% c(-1L, 1L)))
expect_equal(or3s(gnc %between% c(-1L, 1L), t < 1L, e %between% c(-1L, 1L)),
bor3(gnc %between% c(-1L, 1L), t < 1L, e %between% c(-1L, 1L)))
expect_equal(or3s(gnd %between% c(-1L, 1L), w < 9L, n %between% c(-1L, 1L)),
bor3(gnd %between% c(-1L, 1L), w < 9L, n %between% c(-1L, 1L)))
expect_equal(or3s(gne %between% c(-1L, 1L), , ),
bor3(gne %between% c(-1L, 1L), , ))
expect_equal(or3s(gnf %between% c(-1L, 1L), , ),
bor3(gnf %between% c(-1L, 1L), , ))
expect_equal(or3s(gng %between% c(-1L, 1L), , ),
bor3(gng %between% c(-1L, 1L), , ))
expect_equal(or3s(gnh %between% c(-1L, 1L), , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gnh %between% c(-1L, 1L), , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gni %between% c(-1L, 1L), , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gni %between% c(-1L, 1L), , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gnj %between% c(-1L, 1L), , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gnj %between% c(-1L, 1L), , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gnk %between% c(-1L, 1L), x < 0L, ),
bor3(gnk %between% c(-1L, 1L), x < 0L, ))
expect_equal(or3s(gnl %between% c(-1L, 1L), n < 1L, ),
bor3(gnl %between% c(-1L, 1L), n < 1L, ))
expect_equal(or3s(gnm %between% c(-1L, 1L), r < 9L, ),
bor3(gnm %between% c(-1L, 1L), r < 9L, ))
expect_equal(or3s(gnn %between% c(-1L, 1L), z < 0L, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gnn %between% c(-1L, 1L), z < 0L, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gno %between% c(-1L, 1L), d < 1L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gno %between% c(-1L, 1L), d < 1L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gnp %between% c(-1L, 1L), s < 9L, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gnp %between% c(-1L, 1L), s < 9L, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gnq %between% c(-1L, 1L), , ),
bor3(gnq %between% c(-1L, 1L), , ))
expect_equal(or3s(gnr %between% c(-1L, 1L), , ),
bor3(gnr %between% c(-1L, 1L), , ))
expect_equal(or3s(gns %between% c(-1L, 1L), , ),
bor3(gns %between% c(-1L, 1L), , ))
expect_equal(or3s(gnt %between% c(-1L, 1L), , r %in% 1:4),
bor3(gnt %between% c(-1L, 1L), , r %in% 1:4))
expect_equal(or3s(gnu %between% c(-1L, 1L), , s %in% 1:4),
bor3(gnu %between% c(-1L, 1L), , s %in% 1:4))
expect_equal(or3s(gnv %between% c(-1L, 1L), , f %in% 1:4),
bor3(gnv %between% c(-1L, 1L), , f %in% 1:4))
expect_equal(or3s(gnw %between% c(-1L, 1L), d < 0L, ),
bor3(gnw %between% c(-1L, 1L), d < 0L, ))
expect_equal(or3s(gnx %between% c(-1L, 1L), n < 1L, ),
bor3(gnx %between% c(-1L, 1L), n < 1L, ))
expect_equal(or3s(gny %between% c(-1L, 1L), c < 9L, ),
bor3(gny %between% c(-1L, 1L), c < 9L, ))
expect_equal(or3s(gnz %between% c(-1L, 1L), u < 0L, a %in% 1:4),
bor3(gnz %between% c(-1L, 1L), u < 0L, a %in% 1:4))
expect_equal(or3s(goa %between% c(-1L, 1L), p < 1L, q %in% 1:4),
bor3(goa %between% c(-1L, 1L), p < 1L, q %in% 1:4))
expect_equal(or3s(gob %between% c(-1L, 1L), f < 9L, x %in% 1:4),
bor3(gob %between% c(-1L, 1L), f < 9L, x %in% 1:4))
expect_equal(or3s(goc %between% c(-1L, 1L), , ),
bor3(goc %between% c(-1L, 1L), , ))
expect_equal(or3s(god %between% c(-1L, 1L), , ),
bor3(god %between% c(-1L, 1L), , ))
expect_equal(or3s(goe %between% c(-1L, 1L), , ),
bor3(goe %between% c(-1L, 1L), , ))
expect_equal(or3s(gof %between% c(-1L, 1L), , n < 0L),
bor3(gof %between% c(-1L, 1L), , n < 0L))
expect_equal(or3s(gog %between% c(-1L, 1L), , i < 1L),
bor3(gog %between% c(-1L, 1L), , i < 1L))
expect_equal(or3s(goh %between% c(-1L, 1L), , o < 9L),
bor3(goh %between% c(-1L, 1L), , o < 9L))
expect_equal(or3s(goi %between% c(-1L, 1L), u < 0L, ),
bor3(goi %between% c(-1L, 1L), u < 0L, ))
expect_equal(or3s(goj %between% c(-1L, 1L), w < 1L, ),
bor3(goj %between% c(-1L, 1L), w < 1L, ))
expect_equal(or3s(gok %between% c(-1L, 1L), l < 9L, ),
bor3(gok %between% c(-1L, 1L), l < 9L, ))
expect_equal(or3s(gol %between% c(-1L, 1L), f < 0L, g < 0L),
bor3(gol %between% c(-1L, 1L), f < 0L, g < 0L))
expect_equal(or3s(gom %between% c(-1L, 1L), f < 1L, h < 1L),
bor3(gom %between% c(-1L, 1L), f < 1L, h < 1L))
expect_equal(or3s(gon %between% c(-1L, 1L), k < 9L, z < 9L),
bor3(gon %between% c(-1L, 1L), k < 9L, z < 9L))
expect_equal(or3s(goo %between% c(-1L, 1L), , ),
bor3(goo %between% c(-1L, 1L), , ))
expect_equal(or3s(gop %between% c(-1L, 1L), , ),
bor3(gop %between% c(-1L, 1L), , ))
expect_equal(or3s(goq %between% c(-1L, 1L), , ),
bor3(goq %between% c(-1L, 1L), , ))
expect_equal(or3s(gor %between% c(-1L, 1L), , d <= 0L),
bor3(gor %between% c(-1L, 1L), , d <= 0L))
expect_equal(or3s(gos %between% c(-1L, 1L), , b <= 1L),
bor3(gos %between% c(-1L, 1L), , b <= 1L))
expect_equal(or3s(got %between% c(-1L, 1L), , y <= 9L),
bor3(got %between% c(-1L, 1L), , y <= 9L))
expect_equal(or3s(gou %between% c(-1L, 1L), h < 0L, ),
bor3(gou %between% c(-1L, 1L), h < 0L, ))
expect_equal(or3s(gov %between% c(-1L, 1L), b < 1L, ),
bor3(gov %between% c(-1L, 1L), b < 1L, ))
expect_equal(or3s(gow %between% c(-1L, 1L), s < 9L, ),
bor3(gow %between% c(-1L, 1L), s < 9L, ))
expect_equal(or3s(gox %between% c(-1L, 1L), g < 0L, n <= 0L),
bor3(gox %between% c(-1L, 1L), g < 0L, n <= 0L))
expect_equal(or3s(goy %between% c(-1L, 1L), p < 1L, k <= 1L),
bor3(goy %between% c(-1L, 1L), p < 1L, k <= 1L))
expect_equal(or3s(goz %between% c(-1L, 1L), l < 9L, v <= 9L),
bor3(goz %between% c(-1L, 1L), l < 9L, v <= 9L))
expect_equal(or3s(gpa %between% c(-1L, 1L), , ),
bor3(gpa %between% c(-1L, 1L), , ))
expect_equal(or3s(gpb %between% c(-1L, 1L), , ),
bor3(gpb %between% c(-1L, 1L), , ))
expect_equal(or3s(gpc %between% c(-1L, 1L), , ),
bor3(gpc %between% c(-1L, 1L), , ))
expect_equal(or3s(gpd %between% c(-1L, 1L), , f == 0L),
bor3(gpd %between% c(-1L, 1L), , f == 0L))
expect_equal(or3s(gpe %between% c(-1L, 1L), , n == 1L),
bor3(gpe %between% c(-1L, 1L), , n == 1L))
expect_equal(or3s(gpf %between% c(-1L, 1L), , g == 9L),
bor3(gpf %between% c(-1L, 1L), , g == 9L))
expect_equal(or3s(gpg %between% c(-1L, 1L), x < 0L, ),
bor3(gpg %between% c(-1L, 1L), x < 0L, ))
expect_equal(or3s(gph %between% c(-1L, 1L), t < 1L, ),
bor3(gph %between% c(-1L, 1L), t < 1L, ))
expect_equal(or3s(gpi %between% c(-1L, 1L), y < 9L, ),
bor3(gpi %between% c(-1L, 1L), y < 9L, ))
expect_equal(or3s(gpj %between% c(-1L, 1L), y < 0L, g == 0L),
bor3(gpj %between% c(-1L, 1L), y < 0L, g == 0L))
expect_equal(or3s(gpk %between% c(-1L, 1L), y < 1L, x == 1L),
bor3(gpk %between% c(-1L, 1L), y < 1L, x == 1L))
expect_equal(or3s(gpl %between% c(-1L, 1L), m < 9L, z == 9L),
bor3(gpl %between% c(-1L, 1L), m < 9L, z == 9L))
expect_equal(or3s(gpm %between% c(-1L, 1L), , ),
bor3(gpm %between% c(-1L, 1L), , ))
expect_equal(or3s(gpn %between% c(-1L, 1L), , ),
bor3(gpn %between% c(-1L, 1L), , ))
expect_equal(or3s(gpo %between% c(-1L, 1L), , ),
bor3(gpo %between% c(-1L, 1L), , ))
expect_equal(or3s(gpp %between% c(-1L, 1L), , k > 0L),
bor3(gpp %between% c(-1L, 1L), , k > 0L))
expect_equal(or3s(gpq %between% c(-1L, 1L), , n > 1L),
bor3(gpq %between% c(-1L, 1L), , n > 1L))
expect_equal(or3s(gpr %between% c(-1L, 1L), , q > 9L),
bor3(gpr %between% c(-1L, 1L), , q > 9L))
expect_equal(or3s(gps %between% c(-1L, 1L), s < 0L, ),
bor3(gps %between% c(-1L, 1L), s < 0L, ))
expect_equal(or3s(gpt %between% c(-1L, 1L), d < 1L, ),
bor3(gpt %between% c(-1L, 1L), d < 1L, ))
expect_equal(or3s(gpu %between% c(-1L, 1L), n < 9L, ),
bor3(gpu %between% c(-1L, 1L), n < 9L, ))
expect_equal(or3s(gpv %between% c(-1L, 1L), x < 0L, j > 0L),
bor3(gpv %between% c(-1L, 1L), x < 0L, j > 0L))
expect_equal(or3s(gpw %between% c(-1L, 1L), x < 1L, h > 1L),
bor3(gpw %between% c(-1L, 1L), x < 1L, h > 1L))
expect_equal(or3s(gpx %between% c(-1L, 1L), z < 9L, z > 9L),
bor3(gpx %between% c(-1L, 1L), z < 9L, z > 9L))
expect_equal(or3s(gpy %between% c(-1L, 1L), , ),
bor3(gpy %between% c(-1L, 1L), , ))
expect_equal(or3s(gpz %between% c(-1L, 1L), , ),
bor3(gpz %between% c(-1L, 1L), , ))
expect_equal(or3s(gqa %between% c(-1L, 1L), , ),
bor3(gqa %between% c(-1L, 1L), , ))
expect_equal(or3s(gqb %between% c(-1L, 1L), , f >= 0L),
bor3(gqb %between% c(-1L, 1L), , f >= 0L))
expect_equal(or3s(gqc %between% c(-1L, 1L), , o >= 1L),
bor3(gqc %between% c(-1L, 1L), , o >= 1L))
expect_equal(or3s(gqd %between% c(-1L, 1L), , v >= 9L),
bor3(gqd %between% c(-1L, 1L), , v >= 9L))
expect_equal(or3s(gqe %between% c(-1L, 1L), h < 0L, ),
bor3(gqe %between% c(-1L, 1L), h < 0L, ))
expect_equal(or3s(gqf %between% c(-1L, 1L), i < 1L, ),
bor3(gqf %between% c(-1L, 1L), i < 1L, ))
expect_equal(or3s(gqg %between% c(-1L, 1L), b < 9L, ),
bor3(gqg %between% c(-1L, 1L), b < 9L, ))
expect_equal(or3s(gqh %between% c(-1L, 1L), x < 0L, u >= 0L),
bor3(gqh %between% c(-1L, 1L), x < 0L, u >= 0L))
expect_equal(or3s(gqi %between% c(-1L, 1L), u < 1L, r >= 1L),
bor3(gqi %between% c(-1L, 1L), u < 1L, r >= 1L))
expect_equal(or3s(gqj %between% c(-1L, 1L), z < 9L, i >= 9L),
bor3(gqj %between% c(-1L, 1L), z < 9L, i >= 9L))
expect_equal(or3s(gqk %between% c(-1L, 1L), , ),
bor3(gqk %between% c(-1L, 1L), , ))
expect_equal(or3s(gql %between% c(-1L, 1L), , ),
bor3(gql %between% c(-1L, 1L), , ))
expect_equal(or3s(gqm %between% c(-1L, 1L), , ),
bor3(gqm %between% c(-1L, 1L), , ))
expect_equal(or3s(gqn %between% c(-1L, 1L), , logi_k),
bor3(gqn %between% c(-1L, 1L), , logi_k))
expect_equal(or3s(gqo %between% c(-1L, 1L), , logi_u),
bor3(gqo %between% c(-1L, 1L), , logi_u))
expect_equal(or3s(gqp %between% c(-1L, 1L), , logi_l),
bor3(gqp %between% c(-1L, 1L), , logi_l))
expect_equal(or3s(gqq %between% c(-1L, 1L), w <= 0L, ),
bor3(gqq %between% c(-1L, 1L), w <= 0L, ))
expect_equal(or3s(gqr %between% c(-1L, 1L), b <= 1L, ),
bor3(gqr %between% c(-1L, 1L), b <= 1L, ))
expect_equal(or3s(gqs %between% c(-1L, 1L), v <= 9L, ),
bor3(gqs %between% c(-1L, 1L), v <= 9L, ))
expect_equal(or3s(gqt %between% c(-1L, 1L), m <= 0L, logi_i),
bor3(gqt %between% c(-1L, 1L), m <= 0L, logi_i))
expect_equal(or3s(gqu %between% c(-1L, 1L), f <= 1L, logi_z),
bor3(gqu %between% c(-1L, 1L), f <= 1L, logi_z))
expect_equal(or3s(gqv %between% c(-1L, 1L), e <= 9L, logi_a),
bor3(gqv %between% c(-1L, 1L), e <= 9L, logi_a))
expect_equal(or3s(gqw %between% c(-1L, 1L), , ),
bor3(gqw %between% c(-1L, 1L), , ))
expect_equal(or3s(gqx %between% c(-1L, 1L), , ),
bor3(gqx %between% c(-1L, 1L), , ))
expect_equal(or3s(gqy %between% c(-1L, 1L), , ),
bor3(gqy %between% c(-1L, 1L), , ))
expect_equal(or3s(gqz %between% c(-1L, 1L), , !logi_h),
bor3(gqz %between% c(-1L, 1L), , !logi_h))
expect_equal(or3s(gra %between% c(-1L, 1L), , !logi_m),
bor3(gra %between% c(-1L, 1L), , !logi_m))
expect_equal(or3s(grb %between% c(-1L, 1L), , !logi_k),
bor3(grb %between% c(-1L, 1L), , !logi_k))
expect_equal(or3s(grc %between% c(-1L, 1L), o <= 0L, ),
bor3(grc %between% c(-1L, 1L), o <= 0L, ))
expect_equal(or3s(grd %between% c(-1L, 1L), u <= 1L, ),
bor3(grd %between% c(-1L, 1L), u <= 1L, ))
expect_equal(or3s(gre %between% c(-1L, 1L), n <= 9L, ),
bor3(gre %between% c(-1L, 1L), n <= 9L, ))
expect_equal(or3s(grf %between% c(-1L, 1L), r <= 0L, !logi_y),
bor3(grf %between% c(-1L, 1L), r <= 0L, !logi_y))
expect_equal(or3s(grg %between% c(-1L, 1L), s <= 1L, !logi_z),
bor3(grg %between% c(-1L, 1L), s <= 1L, !logi_z))
expect_equal(or3s(grh %between% c(-1L, 1L), n <= 9L, !logi_i),
bor3(grh %between% c(-1L, 1L), n <= 9L, !logi_i))
expect_equal(or3s(gri %between% c(-1L, 1L), , ),
bor3(gri %between% c(-1L, 1L), , ))
expect_equal(or3s(grj %between% c(-1L, 1L), , ),
bor3(grj %between% c(-1L, 1L), , ))
expect_equal(or3s(grk %between% c(-1L, 1L), , ),
bor3(grk %between% c(-1L, 1L), , ))
expect_equal(or3s(grl %between% c(-1L, 1L), , s != 0L),
bor3(grl %between% c(-1L, 1L), , s != 0L))
expect_equal(or3s(grm %between% c(-1L, 1L), , v != 1L),
bor3(grm %between% c(-1L, 1L), , v != 1L))
expect_equal(or3s(grn %between% c(-1L, 1L), , i != 9L),
bor3(grn %between% c(-1L, 1L), , i != 9L))
expect_equal(or3s(gro %between% c(-1L, 1L), m <= 0L, ),
bor3(gro %between% c(-1L, 1L), m <= 0L, ))
expect_equal(or3s(grp %between% c(-1L, 1L), b <= 1L, ),
bor3(grp %between% c(-1L, 1L), b <= 1L, ))
expect_equal(or3s(grq %between% c(-1L, 1L), r <= 9L, ),
bor3(grq %between% c(-1L, 1L), r <= 9L, ))
expect_equal(or3s(grr %between% c(-1L, 1L), a <= 0L, s != 0L),
bor3(grr %between% c(-1L, 1L), a <= 0L, s != 0L))
expect_equal(or3s(grs %between% c(-1L, 1L), j <= 1L, q != 1L),
bor3(grs %between% c(-1L, 1L), j <= 1L, q != 1L))
expect_equal(or3s(grt %between% c(-1L, 1L), t <= 9L, p != 9L),
bor3(grt %between% c(-1L, 1L), t <= 9L, p != 9L))
expect_equal(or3s(gru %between% c(-1L, 1L), , ),
bor3(gru %between% c(-1L, 1L), , ))
expect_equal(or3s(grv %between% c(-1L, 1L), , ),
bor3(grv %between% c(-1L, 1L), , ))
expect_equal(or3s(grw %between% c(-1L, 1L), , ),
bor3(grw %between% c(-1L, 1L), , ))
expect_equal(or3s(grx %between% c(-1L, 1L), , a %between% c(-1L, 1L)),
bor3(grx %between% c(-1L, 1L), , a %between% c(-1L, 1L)))
expect_equal(or3s(gry %between% c(-1L, 1L), , p %between% c(-1L, 1L)),
bor3(gry %between% c(-1L, 1L), , p %between% c(-1L, 1L)))
expect_equal(or3s(grz %between% c(-1L, 1L), , q %between% c(-1L, 1L)),
bor3(grz %between% c(-1L, 1L), , q %between% c(-1L, 1L)))
expect_equal(or3s(gsa %between% c(-1L, 1L), u <= 0L, ),
bor3(gsa %between% c(-1L, 1L), u <= 0L, ))
expect_equal(or3s(gsb %between% c(-1L, 1L), a <= 1L, ),
bor3(gsb %between% c(-1L, 1L), a <= 1L, ))
expect_equal(or3s(gsc %between% c(-1L, 1L), u <= 9L, ),
bor3(gsc %between% c(-1L, 1L), u <= 9L, ))
expect_equal(or3s(gsd %between% c(-1L, 1L), r <= 0L, w %between% c(-1L, 1L)),
bor3(gsd %between% c(-1L, 1L), r <= 0L, w %between% c(-1L, 1L)))
expect_equal(or3s(gse %between% c(-1L, 1L), i <= 1L, w %between% c(-1L, 1L)),
bor3(gse %between% c(-1L, 1L), i <= 1L, w %between% c(-1L, 1L)))
expect_equal(or3s(gsf %between% c(-1L, 1L), g <= 9L, b %between% c(-1L, 1L)),
bor3(gsf %between% c(-1L, 1L), g <= 9L, b %between% c(-1L, 1L)))
expect_equal(or3s(gsg %between% c(-1L, 1L), , ),
bor3(gsg %between% c(-1L, 1L), , ))
expect_equal(or3s(gsh %between% c(-1L, 1L), , ),
bor3(gsh %between% c(-1L, 1L), , ))
expect_equal(or3s(gsi %between% c(-1L, 1L), , ),
bor3(gsi %between% c(-1L, 1L), , ))
expect_equal(or3s(gsj %between% c(-1L, 1L), , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gsj %between% c(-1L, 1L), , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gsk %between% c(-1L, 1L), , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gsk %between% c(-1L, 1L), , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gsl %between% c(-1L, 1L), , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gsl %between% c(-1L, 1L), , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gsm %between% c(-1L, 1L), m <= 0L, ),
bor3(gsm %between% c(-1L, 1L), m <= 0L, ))
expect_equal(or3s(gsn %between% c(-1L, 1L), r <= 1L, ),
bor3(gsn %between% c(-1L, 1L), r <= 1L, ))
expect_equal(or3s(gso %between% c(-1L, 1L), e <= 9L, ),
bor3(gso %between% c(-1L, 1L), e <= 9L, ))
expect_equal(or3s(gsp %between% c(-1L, 1L), v <= 0L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gsp %between% c(-1L, 1L), v <= 0L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gsq %between% c(-1L, 1L), n <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gsq %between% c(-1L, 1L), n <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gsr %between% c(-1L, 1L), d <= 9L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gsr %between% c(-1L, 1L), d <= 9L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gss %between% c(-1L, 1L), , ),
bor3(gss %between% c(-1L, 1L), , ))
expect_equal(or3s(gst %between% c(-1L, 1L), , ),
bor3(gst %between% c(-1L, 1L), , ))
expect_equal(or3s(gsu %between% c(-1L, 1L), , ),
bor3(gsu %between% c(-1L, 1L), , ))
expect_equal(or3s(gsv %between% c(-1L, 1L), , a %in% 1:4),
bor3(gsv %between% c(-1L, 1L), , a %in% 1:4))
expect_equal(or3s(gsw %between% c(-1L, 1L), , f %in% 1:4),
bor3(gsw %between% c(-1L, 1L), , f %in% 1:4))
expect_equal(or3s(gsx %between% c(-1L, 1L), , x %in% 1:4),
bor3(gsx %between% c(-1L, 1L), , x %in% 1:4))
expect_equal(or3s(gsy %between% c(-1L, 1L), o <= 0L, ),
bor3(gsy %between% c(-1L, 1L), o <= 0L, ))
expect_equal(or3s(gsz %between% c(-1L, 1L), k <= 1L, ),
bor3(gsz %between% c(-1L, 1L), k <= 1L, ))
expect_equal(or3s(gta %between% c(-1L, 1L), k <= 9L, ),
bor3(gta %between% c(-1L, 1L), k <= 9L, ))
expect_equal(or3s(gtb %between% c(-1L, 1L), i <= 0L, a %in% 1:4),
bor3(gtb %between% c(-1L, 1L), i <= 0L, a %in% 1:4))
expect_equal(or3s(gtc %between% c(-1L, 1L), w <= 1L, g %in% 1:4),
bor3(gtc %between% c(-1L, 1L), w <= 1L, g %in% 1:4))
expect_equal(or3s(gtd %between% c(-1L, 1L), v <= 9L, h %in% 1:4),
bor3(gtd %between% c(-1L, 1L), v <= 9L, h %in% 1:4))
expect_equal(or3s(gte %between% c(-1L, 1L), , ),
bor3(gte %between% c(-1L, 1L), , ))
expect_equal(or3s(gtf %between% c(-1L, 1L), , ),
bor3(gtf %between% c(-1L, 1L), , ))
expect_equal(or3s(gtg %between% c(-1L, 1L), , ),
bor3(gtg %between% c(-1L, 1L), , ))
expect_equal(or3s(gth %between% c(-1L, 1L), , d < 0L),
bor3(gth %between% c(-1L, 1L), , d < 0L))
expect_equal(or3s(gti %between% c(-1L, 1L), , p < 1L),
bor3(gti %between% c(-1L, 1L), , p < 1L))
expect_equal(or3s(gtj %between% c(-1L, 1L), , c < 9L),
bor3(gtj %between% c(-1L, 1L), , c < 9L))
expect_equal(or3s(gtk %between% c(-1L, 1L), f <= 0L, ),
bor3(gtk %between% c(-1L, 1L), f <= 0L, ))
expect_equal(or3s(gtl %between% c(-1L, 1L), f <= 1L, ),
bor3(gtl %between% c(-1L, 1L), f <= 1L, ))
expect_equal(or3s(gtm %between% c(-1L, 1L), q <= 9L, ),
bor3(gtm %between% c(-1L, 1L), q <= 9L, ))
expect_equal(or3s(gtn %between% c(-1L, 1L), l <= 0L, x < 0L),
bor3(gtn %between% c(-1L, 1L), l <= 0L, x < 0L))
expect_equal(or3s(gto %between% c(-1L, 1L), q <= 1L, p < 1L),
bor3(gto %between% c(-1L, 1L), q <= 1L, p < 1L))
expect_equal(or3s(gtp %between% c(-1L, 1L), j <= 9L, n < 9L),
bor3(gtp %between% c(-1L, 1L), j <= 9L, n < 9L))
expect_equal(or3s(gtq %between% c(-1L, 1L), , ),
bor3(gtq %between% c(-1L, 1L), , ))
expect_equal(or3s(gtr %between% c(-1L, 1L), , ),
bor3(gtr %between% c(-1L, 1L), , ))
expect_equal(or3s(gts %between% c(-1L, 1L), , ),
bor3(gts %between% c(-1L, 1L), , ))
expect_equal(or3s(gtt %between% c(-1L, 1L), , k <= 0L),
bor3(gtt %between% c(-1L, 1L), , k <= 0L))
expect_equal(or3s(gtu %between% c(-1L, 1L), , u <= 1L),
bor3(gtu %between% c(-1L, 1L), , u <= 1L))
expect_equal(or3s(gtv %between% c(-1L, 1L), , c <= 9L),
bor3(gtv %between% c(-1L, 1L), , c <= 9L))
expect_equal(or3s(gtw %between% c(-1L, 1L), s <= 0L, ),
bor3(gtw %between% c(-1L, 1L), s <= 0L, ))
expect_equal(or3s(gtx %between% c(-1L, 1L), e <= 1L, ),
bor3(gtx %between% c(-1L, 1L), e <= 1L, ))
expect_equal(or3s(gty %between% c(-1L, 1L), v <= 9L, ),
bor3(gty %between% c(-1L, 1L), v <= 9L, ))
expect_equal(or3s(gtz %between% c(-1L, 1L), d <= 0L, k <= 0L),
bor3(gtz %between% c(-1L, 1L), d <= 0L, k <= 0L))
expect_equal(or3s(gua %between% c(-1L, 1L), c <= 1L, d <= 1L),
bor3(gua %between% c(-1L, 1L), c <= 1L, d <= 1L))
expect_equal(or3s(gub %between% c(-1L, 1L), g <= 9L, r <= 9L),
bor3(gub %between% c(-1L, 1L), g <= 9L, r <= 9L))
expect_equal(or3s(guc %between% c(-1L, 1L), , ),
bor3(guc %between% c(-1L, 1L), , ))
expect_equal(or3s(gud %between% c(-1L, 1L), , ),
bor3(gud %between% c(-1L, 1L), , ))
expect_equal(or3s(gue %between% c(-1L, 1L), , ),
bor3(gue %between% c(-1L, 1L), , ))
expect_equal(or3s(guf %between% c(-1L, 1L), , q == 0L),
bor3(guf %between% c(-1L, 1L), , q == 0L))
expect_equal(or3s(gug %between% c(-1L, 1L), , k == 1L),
bor3(gug %between% c(-1L, 1L), , k == 1L))
expect_equal(or3s(guh %between% c(-1L, 1L), , x == 9L),
bor3(guh %between% c(-1L, 1L), , x == 9L))
expect_equal(or3s(gui %between% c(-1L, 1L), b <= 0L, ),
bor3(gui %between% c(-1L, 1L), b <= 0L, ))
expect_equal(or3s(guj %between% c(-1L, 1L), v <= 1L, ),
bor3(guj %between% c(-1L, 1L), v <= 1L, ))
expect_equal(or3s(guk %between% c(-1L, 1L), k <= 9L, ),
bor3(guk %between% c(-1L, 1L), k <= 9L, ))
expect_equal(or3s(gul %between% c(-1L, 1L), h <= 0L, m == 0L),
bor3(gul %between% c(-1L, 1L), h <= 0L, m == 0L))
expect_equal(or3s(gum %between% c(-1L, 1L), h <= 1L, k == 1L),
bor3(gum %between% c(-1L, 1L), h <= 1L, k == 1L))
expect_equal(or3s(gun %between% c(-1L, 1L), j <= 9L, v == 9L),
bor3(gun %between% c(-1L, 1L), j <= 9L, v == 9L))
expect_equal(or3s(guo %between% c(-1L, 1L), , ),
bor3(guo %between% c(-1L, 1L), , ))
expect_equal(or3s(gup %between% c(-1L, 1L), , ),
bor3(gup %between% c(-1L, 1L), , ))
expect_equal(or3s(guq %between% c(-1L, 1L), , ),
bor3(guq %between% c(-1L, 1L), , ))
expect_equal(or3s(gur %between% c(-1L, 1L), , n > 0L),
bor3(gur %between% c(-1L, 1L), , n > 0L))
expect_equal(or3s(gus %between% c(-1L, 1L), , p > 1L),
bor3(gus %between% c(-1L, 1L), , p > 1L))
expect_equal(or3s(gut %between% c(-1L, 1L), , j > 9L),
bor3(gut %between% c(-1L, 1L), , j > 9L))
expect_equal(or3s(guu %between% c(-1L, 1L), u <= 0L, ),
bor3(guu %between% c(-1L, 1L), u <= 0L, ))
expect_equal(or3s(guv %between% c(-1L, 1L), s <= 1L, ),
bor3(guv %between% c(-1L, 1L), s <= 1L, ))
expect_equal(or3s(guw %between% c(-1L, 1L), k <= 9L, ),
bor3(guw %between% c(-1L, 1L), k <= 9L, ))
expect_equal(or3s(gux %between% c(-1L, 1L), e <= 0L, e > 0L),
bor3(gux %between% c(-1L, 1L), e <= 0L, e > 0L))
expect_equal(or3s(guy %between% c(-1L, 1L), y <= 1L, u > 1L),
bor3(guy %between% c(-1L, 1L), y <= 1L, u > 1L))
expect_equal(or3s(guz %between% c(-1L, 1L), p <= 9L, m > 9L),
bor3(guz %between% c(-1L, 1L), p <= 9L, m > 9L))
expect_equal(or3s(gva %between% c(-1L, 1L), , ),
bor3(gva %between% c(-1L, 1L), , ))
expect_equal(or3s(gvb %between% c(-1L, 1L), , ),
bor3(gvb %between% c(-1L, 1L), , ))
expect_equal(or3s(gvc %between% c(-1L, 1L), , ),
bor3(gvc %between% c(-1L, 1L), , ))
expect_equal(or3s(gvd %between% c(-1L, 1L), , k >= 0L),
bor3(gvd %between% c(-1L, 1L), , k >= 0L))
expect_equal(or3s(gve %between% c(-1L, 1L), , b >= 1L),
bor3(gve %between% c(-1L, 1L), , b >= 1L))
expect_equal(or3s(gvf %between% c(-1L, 1L), , o >= 9L),
bor3(gvf %between% c(-1L, 1L), , o >= 9L))
expect_equal(or3s(gvg %between% c(-1L, 1L), s <= 0L, ),
bor3(gvg %between% c(-1L, 1L), s <= 0L, ))
expect_equal(or3s(gvh %between% c(-1L, 1L), p <= 1L, ),
bor3(gvh %between% c(-1L, 1L), p <= 1L, ))
expect_equal(or3s(gvi %between% c(-1L, 1L), z <= 9L, ),
bor3(gvi %between% c(-1L, 1L), z <= 9L, ))
expect_equal(or3s(gvj %between% c(-1L, 1L), t <= 0L, k >= 0L),
bor3(gvj %between% c(-1L, 1L), t <= 0L, k >= 0L))
expect_equal(or3s(gvk %between% c(-1L, 1L), d <= 1L, b >= 1L),
bor3(gvk %between% c(-1L, 1L), d <= 1L, b >= 1L))
expect_equal(or3s(gvl %between% c(-1L, 1L), c <= 9L, t >= 9L),
bor3(gvl %between% c(-1L, 1L), c <= 9L, t >= 9L))
expect_equal(or3s(gvm %between% c(-1L, 1L), , ),
bor3(gvm %between% c(-1L, 1L), , ))
expect_equal(or3s(gvn %between% c(-1L, 1L), , ),
bor3(gvn %between% c(-1L, 1L), , ))
expect_equal(or3s(gvo %between% c(-1L, 1L), , ),
bor3(gvo %between% c(-1L, 1L), , ))
expect_equal(or3s(gvp %between% c(-1L, 1L), , logi_l),
bor3(gvp %between% c(-1L, 1L), , logi_l))
expect_equal(or3s(gvq %between% c(-1L, 1L), , logi_f),
bor3(gvq %between% c(-1L, 1L), , logi_f))
expect_equal(or3s(gvr %between% c(-1L, 1L), , logi_f),
bor3(gvr %between% c(-1L, 1L), , logi_f))
expect_equal(or3s(gvs %between% c(-1L, 1L), e == 0L, ),
bor3(gvs %between% c(-1L, 1L), e == 0L, ))
expect_equal(or3s(gvt %between% c(-1L, 1L), e == 1L, ),
bor3(gvt %between% c(-1L, 1L), e == 1L, ))
expect_equal(or3s(gvu %between% c(-1L, 1L), z == 9L, ),
bor3(gvu %between% c(-1L, 1L), z == 9L, ))
expect_equal(or3s(gvv %between% c(-1L, 1L), k == 0L, logi_a),
bor3(gvv %between% c(-1L, 1L), k == 0L, logi_a))
expect_equal(or3s(gvw %between% c(-1L, 1L), p == 1L, logi_o),
bor3(gvw %between% c(-1L, 1L), p == 1L, logi_o))
expect_equal(or3s(gvx %between% c(-1L, 1L), m == 9L, logi_v),
bor3(gvx %between% c(-1L, 1L), m == 9L, logi_v))
expect_equal(or3s(gvy %between% c(-1L, 1L), , ),
bor3(gvy %between% c(-1L, 1L), , ))
expect_equal(or3s(gvz %between% c(-1L, 1L), , ),
bor3(gvz %between% c(-1L, 1L), , ))
expect_equal(or3s(gwa %between% c(-1L, 1L), , ),
bor3(gwa %between% c(-1L, 1L), , ))
expect_equal(or3s(gwb %between% c(-1L, 1L), , !logi_z),
bor3(gwb %between% c(-1L, 1L), , !logi_z))
expect_equal(or3s(gwc %between% c(-1L, 1L), , !logi_b),
bor3(gwc %between% c(-1L, 1L), , !logi_b))
expect_equal(or3s(gwd %between% c(-1L, 1L), , !logi_r),
bor3(gwd %between% c(-1L, 1L), , !logi_r))
expect_equal(or3s(gwe %between% c(-1L, 1L), f == 0L, ),
bor3(gwe %between% c(-1L, 1L), f == 0L, ))
expect_equal(or3s(gwf %between% c(-1L, 1L), i == 1L, ),
bor3(gwf %between% c(-1L, 1L), i == 1L, ))
expect_equal(or3s(gwg %between% c(-1L, 1L), a == 9L, ),
bor3(gwg %between% c(-1L, 1L), a == 9L, ))
expect_equal(or3s(gwh %between% c(-1L, 1L), t == 0L, !logi_d),
bor3(gwh %between% c(-1L, 1L), t == 0L, !logi_d))
expect_equal(or3s(gwi %between% c(-1L, 1L), a == 1L, !logi_o),
bor3(gwi %between% c(-1L, 1L), a == 1L, !logi_o))
expect_equal(or3s(gwj %between% c(-1L, 1L), b == 9L, !logi_x),
bor3(gwj %between% c(-1L, 1L), b == 9L, !logi_x))
expect_equal(or3s(gwk %between% c(-1L, 1L), , ),
bor3(gwk %between% c(-1L, 1L), , ))
expect_equal(or3s(gwl %between% c(-1L, 1L), , ),
bor3(gwl %between% c(-1L, 1L), , ))
expect_equal(or3s(gwm %between% c(-1L, 1L), , ),
bor3(gwm %between% c(-1L, 1L), , ))
expect_equal(or3s(gwn %between% c(-1L, 1L), , d != 0L),
bor3(gwn %between% c(-1L, 1L), , d != 0L))
expect_equal(or3s(gwo %between% c(-1L, 1L), , f != 1L),
bor3(gwo %between% c(-1L, 1L), , f != 1L))
expect_equal(or3s(gwp %between% c(-1L, 1L), , z != 9L),
bor3(gwp %between% c(-1L, 1L), , z != 9L))
expect_equal(or3s(gwq %between% c(-1L, 1L), l == 0L, ),
bor3(gwq %between% c(-1L, 1L), l == 0L, ))
expect_equal(or3s(gwr %between% c(-1L, 1L), h == 1L, ),
bor3(gwr %between% c(-1L, 1L), h == 1L, ))
expect_equal(or3s(gws %between% c(-1L, 1L), g == 9L, ),
bor3(gws %between% c(-1L, 1L), g == 9L, ))
expect_equal(or3s(gwt %between% c(-1L, 1L), n == 0L, v != 0L),
bor3(gwt %between% c(-1L, 1L), n == 0L, v != 0L))
expect_equal(or3s(gwu %between% c(-1L, 1L), s == 1L, a != 1L),
bor3(gwu %between% c(-1L, 1L), s == 1L, a != 1L))
expect_equal(or3s(gwv %between% c(-1L, 1L), w == 9L, k != 9L),
bor3(gwv %between% c(-1L, 1L), w == 9L, k != 9L))
expect_equal(or3s(gww %between% c(-1L, 1L), , ),
bor3(gww %between% c(-1L, 1L), , ))
expect_equal(or3s(gwx %between% c(-1L, 1L), , ),
bor3(gwx %between% c(-1L, 1L), , ))
expect_equal(or3s(gwy %between% c(-1L, 1L), , ),
bor3(gwy %between% c(-1L, 1L), , ))
expect_equal(or3s(gwz %between% c(-1L, 1L), , l %between% c(-1L, 1L)),
bor3(gwz %between% c(-1L, 1L), , l %between% c(-1L, 1L)))
expect_equal(or3s(gxa %between% c(-1L, 1L), , k %between% c(-1L, 1L)),
bor3(gxa %between% c(-1L, 1L), , k %between% c(-1L, 1L)))
expect_equal(or3s(gxb %between% c(-1L, 1L), , i %between% c(-1L, 1L)),
bor3(gxb %between% c(-1L, 1L), , i %between% c(-1L, 1L)))
expect_equal(or3s(gxc %between% c(-1L, 1L), v == 0L, ),
bor3(gxc %between% c(-1L, 1L), v == 0L, ))
expect_equal(or3s(gxd %between% c(-1L, 1L), j == 1L, ),
bor3(gxd %between% c(-1L, 1L), j == 1L, ))
expect_equal(or3s(gxe %between% c(-1L, 1L), l == 9L, ),
bor3(gxe %between% c(-1L, 1L), l == 9L, ))
expect_equal(or3s(gxf %between% c(-1L, 1L), u == 0L, y %between% c(-1L, 1L)),
bor3(gxf %between% c(-1L, 1L), u == 0L, y %between% c(-1L, 1L)))
expect_equal(or3s(gxg %between% c(-1L, 1L), j == 1L, h %between% c(-1L, 1L)),
bor3(gxg %between% c(-1L, 1L), j == 1L, h %between% c(-1L, 1L)))
expect_equal(or3s(gxh %between% c(-1L, 1L), o == 9L, s %between% c(-1L, 1L)),
bor3(gxh %between% c(-1L, 1L), o == 9L, s %between% c(-1L, 1L)))
expect_equal(or3s(gxi %between% c(-1L, 1L), , ),
bor3(gxi %between% c(-1L, 1L), , ))
expect_equal(or3s(gxj %between% c(-1L, 1L), , ),
bor3(gxj %between% c(-1L, 1L), , ))
expect_equal(or3s(gxk %between% c(-1L, 1L), , ),
bor3(gxk %between% c(-1L, 1L), , ))
expect_equal(or3s(gxl %between% c(-1L, 1L), , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gxl %between% c(-1L, 1L), , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gxm %between% c(-1L, 1L), , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gxm %between% c(-1L, 1L), , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gxn %between% c(-1L, 1L), , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gxn %between% c(-1L, 1L), , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gxo %between% c(-1L, 1L), a == 0L, ),
bor3(gxo %between% c(-1L, 1L), a == 0L, ))
expect_equal(or3s(gxp %between% c(-1L, 1L), t == 1L, ),
bor3(gxp %between% c(-1L, 1L), t == 1L, ))
expect_equal(or3s(gxq %between% c(-1L, 1L), o == 9L, ),
bor3(gxq %between% c(-1L, 1L), o == 9L, ))
expect_equal(or3s(gxr %between% c(-1L, 1L), g == 0L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gxr %between% c(-1L, 1L), g == 0L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gxs %between% c(-1L, 1L), t == 1L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gxs %between% c(-1L, 1L), t == 1L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gxt %between% c(-1L, 1L), h == 9L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(gxt %between% c(-1L, 1L), h == 9L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(gxu %between% c(-1L, 1L), , ),
bor3(gxu %between% c(-1L, 1L), , ))
expect_equal(or3s(gxv %between% c(-1L, 1L), , ),
bor3(gxv %between% c(-1L, 1L), , ))
expect_equal(or3s(gxw %between% c(-1L, 1L), , ),
bor3(gxw %between% c(-1L, 1L), , ))
expect_equal(or3s(gxx %between% c(-1L, 1L), , v %in% 1:4),
bor3(gxx %between% c(-1L, 1L), , v %in% 1:4))
expect_equal(or3s(gxy %between% c(-1L, 1L), , i %in% 1:4),
bor3(gxy %between% c(-1L, 1L), , i %in% 1:4))
expect_equal(or3s(gxz %between% c(-1L, 1L), , e %in% 1:4),
bor3(gxz %between% c(-1L, 1L), , e %in% 1:4))
expect_equal(or3s(gya %between% c(-1L, 1L), u == 0L, ),
bor3(gya %between% c(-1L, 1L), u == 0L, ))
expect_equal(or3s(gyb %between% c(-1L, 1L), e == 1L, ),
bor3(gyb %between% c(-1L, 1L), e == 1L, ))
expect_equal(or3s(gyc %between% c(-1L, 1L), o == 9L, ),
bor3(gyc %between% c(-1L, 1L), o == 9L, ))
expect_equal(or3s(gyd %between% c(-1L, 1L), b == 0L, r %in% 1:4),
bor3(gyd %between% c(-1L, 1L), b == 0L, r %in% 1:4))
expect_equal(or3s(gye %between% c(-1L, 1L), v == 1L, z %in% 1:4),
bor3(gye %between% c(-1L, 1L), v == 1L, z %in% 1:4))
expect_equal(or3s(gyf %between% c(-1L, 1L), w == 9L, a %in% 1:4),
bor3(gyf %between% c(-1L, 1L), w == 9L, a %in% 1:4))
expect_equal(or3s(gyg %between% c(-1L, 1L), , ),
bor3(gyg %between% c(-1L, 1L), , ))
expect_equal(or3s(gyh %between% c(-1L, 1L), , ),
bor3(gyh %between% c(-1L, 1L), , ))
expect_equal(or3s(gyi %between% c(-1L, 1L), , ),
bor3(gyi %between% c(-1L, 1L), , ))
expect_equal(or3s(gyj %between% c(-1L, 1L), , o < 0L),
bor3(gyj %between% c(-1L, 1L), , o < 0L))
expect_equal(or3s(gyk %between% c(-1L, 1L), , t < 1L),
bor3(gyk %between% c(-1L, 1L), , t < 1L))
expect_equal(or3s(gyl %between% c(-1L, 1L), , v < 9L),
bor3(gyl %between% c(-1L, 1L), , v < 9L))
expect_equal(or3s(gym %between% c(-1L, 1L), y == 0L, ),
bor3(gym %between% c(-1L, 1L), y == 0L, ))
expect_equal(or3s(gyn %between% c(-1L, 1L), a == 1L, ),
bor3(gyn %between% c(-1L, 1L), a == 1L, ))
expect_equal(or3s(gyo %between% c(-1L, 1L), c == 9L, ),
bor3(gyo %between% c(-1L, 1L), c == 9L, ))
expect_equal(or3s(gyp %between% c(-1L, 1L), d == 0L, y < 0L),
bor3(gyp %between% c(-1L, 1L), d == 0L, y < 0L))
expect_equal(or3s(gyq %between% c(-1L, 1L), x == 1L, i < 1L),
bor3(gyq %between% c(-1L, 1L), x == 1L, i < 1L))
expect_equal(or3s(gyr %between% c(-1L, 1L), g == 9L, t < 9L),
bor3(gyr %between% c(-1L, 1L), g == 9L, t < 9L))
expect_equal(or3s(gys %between% c(-1L, 1L), , ),
bor3(gys %between% c(-1L, 1L), , ))
expect_equal(or3s(gyt %between% c(-1L, 1L), , ),
bor3(gyt %between% c(-1L, 1L), , ))
expect_equal(or3s(gyu %between% c(-1L, 1L), , ),
bor3(gyu %between% c(-1L, 1L), , ))
expect_equal(or3s(gyv %between% c(-1L, 1L), , e <= 0L),
bor3(gyv %between% c(-1L, 1L), , e <= 0L))
expect_equal(or3s(gyw %between% c(-1L, 1L), , r <= 1L),
bor3(gyw %between% c(-1L, 1L), , r <= 1L))
expect_equal(or3s(gyx %between% c(-1L, 1L), , e <= 9L),
bor3(gyx %between% c(-1L, 1L), , e <= 9L))
expect_equal(or3s(gyy %between% c(-1L, 1L), v == 0L, ),
bor3(gyy %between% c(-1L, 1L), v == 0L, ))
expect_equal(or3s(gyz %between% c(-1L, 1L), l == 1L, ),
bor3(gyz %between% c(-1L, 1L), l == 1L, ))
expect_equal(or3s(ha %between% c(-1L, 1L), q == 9L, ),
bor3(ha %between% c(-1L, 1L), q == 9L, ))
expect_equal(or3s(hb %between% c(-1L, 1L), g == 0L, z <= 0L),
bor3(hb %between% c(-1L, 1L), g == 0L, z <= 0L))
expect_equal(or3s(hc %between% c(-1L, 1L), f == 1L, d <= 1L),
bor3(hc %between% c(-1L, 1L), f == 1L, d <= 1L))
expect_equal(or3s(hd %between% c(-1L, 1L), r == 9L, q <= 9L),
bor3(hd %between% c(-1L, 1L), r == 9L, q <= 9L))
expect_equal(or3s(he %between% c(-1L, 1L), , ),
bor3(he %between% c(-1L, 1L), , ))
expect_equal(or3s(hf %between% c(-1L, 1L), , ),
bor3(hf %between% c(-1L, 1L), , ))
expect_equal(or3s(hg %between% c(-1L, 1L), , ),
bor3(hg %between% c(-1L, 1L), , ))
expect_equal(or3s(hh %between% c(-1L, 1L), , o == 0L),
bor3(hh %between% c(-1L, 1L), , o == 0L))
expect_equal(or3s(hi %between% c(-1L, 1L), , a == 1L),
bor3(hi %between% c(-1L, 1L), , a == 1L))
expect_equal(or3s(hj %between% c(-1L, 1L), , g == 9L),
bor3(hj %between% c(-1L, 1L), , g == 9L))
expect_equal(or3s(hk %between% c(-1L, 1L), h == 0L, ),
bor3(hk %between% c(-1L, 1L), h == 0L, ))
expect_equal(or3s(hl %between% c(-1L, 1L), w == 1L, ),
bor3(hl %between% c(-1L, 1L), w == 1L, ))
expect_equal(or3s(hm %between% c(-1L, 1L), s == 9L, ),
bor3(hm %between% c(-1L, 1L), s == 9L, ))
expect_equal(or3s(hn %between% c(-1L, 1L), q == 0L, n == 0L),
bor3(hn %between% c(-1L, 1L), q == 0L, n == 0L))
expect_equal(or3s(ho %between% c(-1L, 1L), m == 1L, z == 1L),
bor3(ho %between% c(-1L, 1L), m == 1L, z == 1L))
expect_equal(or3s(hp %between% c(-1L, 1L), o == 9L, x == 9L),
bor3(hp %between% c(-1L, 1L), o == 9L, x == 9L))
expect_equal(or3s(hq %between% c(-1L, 1L), , ),
bor3(hq %between% c(-1L, 1L), , ))
expect_equal(or3s(hr %between% c(-1L, 1L), , ),
bor3(hr %between% c(-1L, 1L), , ))
expect_equal(or3s(hs %between% c(-1L, 1L), , ),
bor3(hs %between% c(-1L, 1L), , ))
expect_equal(or3s(ht %between% c(-1L, 1L), , q > 0L),
bor3(ht %between% c(-1L, 1L), , q > 0L))
expect_equal(or3s(hu %between% c(-1L, 1L), , s > 1L),
bor3(hu %between% c(-1L, 1L), , s > 1L))
expect_equal(or3s(hv %between% c(-1L, 1L), , o > 9L),
bor3(hv %between% c(-1L, 1L), , o > 9L))
expect_equal(or3s(hw %between% c(-1L, 1L), i == 0L, ),
bor3(hw %between% c(-1L, 1L), i == 0L, ))
expect_equal(or3s(hx %between% c(-1L, 1L), v == 1L, ),
bor3(hx %between% c(-1L, 1L), v == 1L, ))
expect_equal(or3s(hy %between% c(-1L, 1L), e == 9L, ),
bor3(hy %between% c(-1L, 1L), e == 9L, ))
expect_equal(or3s(hz %between% c(-1L, 1L), b == 0L, t > 0L),
bor3(hz %between% c(-1L, 1L), b == 0L, t > 0L))
expect_equal(or3s(haa %between% c(-1L, 1L), r == 1L, l > 1L),
bor3(haa %between% c(-1L, 1L), r == 1L, l > 1L))
expect_equal(or3s(hab %between% c(-1L, 1L), f == 9L, s > 9L),
bor3(hab %between% c(-1L, 1L), f == 9L, s > 9L))
expect_equal(or3s(hac %between% c(-1L, 1L), , ),
bor3(hac %between% c(-1L, 1L), , ))
expect_equal(or3s(had %between% c(-1L, 1L), , ),
bor3(had %between% c(-1L, 1L), , ))
expect_equal(or3s(hae %between% c(-1L, 1L), , ),
bor3(hae %between% c(-1L, 1L), , ))
expect_equal(or3s(haf %between% c(-1L, 1L), , e >= 0L),
bor3(haf %between% c(-1L, 1L), , e >= 0L))
expect_equal(or3s(hag %between% c(-1L, 1L), , v >= 1L),
bor3(hag %between% c(-1L, 1L), , v >= 1L))
expect_equal(or3s(hah %between% c(-1L, 1L), , a >= 9L),
bor3(hah %between% c(-1L, 1L), , a >= 9L))
expect_equal(or3s(hai %between% c(-1L, 1L), r == 0L, ),
bor3(hai %between% c(-1L, 1L), r == 0L, ))
expect_equal(or3s(haj %between% c(-1L, 1L), g == 1L, ),
bor3(haj %between% c(-1L, 1L), g == 1L, ))
expect_equal(or3s(hak %between% c(-1L, 1L), z == 9L, ),
bor3(hak %between% c(-1L, 1L), z == 9L, ))
expect_equal(or3s(hal %between% c(-1L, 1L), n == 0L, a >= 0L),
bor3(hal %between% c(-1L, 1L), n == 0L, a >= 0L))
expect_equal(or3s(ham %between% c(-1L, 1L), z == 1L, l >= 1L),
bor3(ham %between% c(-1L, 1L), z == 1L, l >= 1L))
expect_equal(or3s(han %between% c(-1L, 1L), s == 9L, g >= 9L),
bor3(han %between% c(-1L, 1L), s == 9L, g >= 9L))
expect_equal(or3s(hao %between% c(-1L, 1L), , ),
bor3(hao %between% c(-1L, 1L), , ))
expect_equal(or3s(hap %between% c(-1L, 1L), , ),
bor3(hap %between% c(-1L, 1L), , ))
expect_equal(or3s(haq %between% c(-1L, 1L), , ),
bor3(haq %between% c(-1L, 1L), , ))
expect_equal(or3s(har %between% c(-1L, 1L), , logi_j),
bor3(har %between% c(-1L, 1L), , logi_j))
expect_equal(or3s(has %between% c(-1L, 1L), , logi_p),
bor3(has %between% c(-1L, 1L), , logi_p))
expect_equal(or3s(hat %between% c(-1L, 1L), , logi_k),
bor3(hat %between% c(-1L, 1L), , logi_k))
expect_equal(or3s(hau %between% c(-1L, 1L), l > 0L, ),
bor3(hau %between% c(-1L, 1L), l > 0L, ))
expect_equal(or3s(hav %between% c(-1L, 1L), i > 1L, ),
bor3(hav %between% c(-1L, 1L), i > 1L, ))
expect_equal(or3s(haw %between% c(-1L, 1L), m > 9L, ),
bor3(haw %between% c(-1L, 1L), m > 9L, ))
expect_equal(or3s(hax %between% c(-1L, 1L), l > 0L, logi_d),
bor3(hax %between% c(-1L, 1L), l > 0L, logi_d))
expect_equal(or3s(hay %between% c(-1L, 1L), f > 1L, logi_y),
bor3(hay %between% c(-1L, 1L), f > 1L, logi_y))
expect_equal(or3s(haz %between% c(-1L, 1L), z > 9L, logi_a),
bor3(haz %between% c(-1L, 1L), z > 9L, logi_a))
expect_equal(or3s(hba %between% c(-1L, 1L), , ),
bor3(hba %between% c(-1L, 1L), , ))
expect_equal(or3s(hbb %between% c(-1L, 1L), , ),
bor3(hbb %between% c(-1L, 1L), , ))
expect_equal(or3s(hbc %between% c(-1L, 1L), , ),
bor3(hbc %between% c(-1L, 1L), , ))
expect_equal(or3s(hbd %between% c(-1L, 1L), , !logi_p),
bor3(hbd %between% c(-1L, 1L), , !logi_p))
expect_equal(or3s(hbe %between% c(-1L, 1L), , !logi_e),
bor3(hbe %between% c(-1L, 1L), , !logi_e))
expect_equal(or3s(hbf %between% c(-1L, 1L), , !logi_n),
bor3(hbf %between% c(-1L, 1L), , !logi_n))
expect_equal(or3s(hbg %between% c(-1L, 1L), l > 0L, ),
bor3(hbg %between% c(-1L, 1L), l > 0L, ))
expect_equal(or3s(hbh %between% c(-1L, 1L), e > 1L, ),
bor3(hbh %between% c(-1L, 1L), e > 1L, ))
expect_equal(or3s(hbi %between% c(-1L, 1L), v > 9L, ),
bor3(hbi %between% c(-1L, 1L), v > 9L, ))
expect_equal(or3s(hbj %between% c(-1L, 1L), m > 0L, !logi_l),
bor3(hbj %between% c(-1L, 1L), m > 0L, !logi_l))
expect_equal(or3s(hbk %between% c(-1L, 1L), k > 1L, !logi_e),
bor3(hbk %between% c(-1L, 1L), k > 1L, !logi_e))
expect_equal(or3s(hbl %between% c(-1L, 1L), c > 9L, !logi_f),
bor3(hbl %between% c(-1L, 1L), c > 9L, !logi_f))
expect_equal(or3s(hbm %between% c(-1L, 1L), , ),
bor3(hbm %between% c(-1L, 1L), , ))
expect_equal(or3s(hbn %between% c(-1L, 1L), , ),
bor3(hbn %between% c(-1L, 1L), , ))
expect_equal(or3s(hbo %between% c(-1L, 1L), , ),
bor3(hbo %between% c(-1L, 1L), , ))
expect_equal(or3s(hbp %between% c(-1L, 1L), , o != 0L),
bor3(hbp %between% c(-1L, 1L), , o != 0L))
expect_equal(or3s(hbq %between% c(-1L, 1L), , d != 1L),
bor3(hbq %between% c(-1L, 1L), , d != 1L))
expect_equal(or3s(hbr %between% c(-1L, 1L), , s != 9L),
bor3(hbr %between% c(-1L, 1L), , s != 9L))
expect_equal(or3s(hbs %between% c(-1L, 1L), e > 0L, ),
bor3(hbs %between% c(-1L, 1L), e > 0L, ))
expect_equal(or3s(hbt %between% c(-1L, 1L), d > 1L, ),
bor3(hbt %between% c(-1L, 1L), d > 1L, ))
expect_equal(or3s(hbu %between% c(-1L, 1L), d > 9L, ),
bor3(hbu %between% c(-1L, 1L), d > 9L, ))
expect_equal(or3s(hbv %between% c(-1L, 1L), d > 0L, m != 0L),
bor3(hbv %between% c(-1L, 1L), d > 0L, m != 0L))
expect_equal(or3s(hbw %between% c(-1L, 1L), c > 1L, e != 1L),
bor3(hbw %between% c(-1L, 1L), c > 1L, e != 1L))
expect_equal(or3s(hbx %between% c(-1L, 1L), s > 9L, q != 9L),
bor3(hbx %between% c(-1L, 1L), s > 9L, q != 9L))
expect_equal(or3s(hby %between% c(-1L, 1L), , ),
bor3(hby %between% c(-1L, 1L), , ))
expect_equal(or3s(hbz %between% c(-1L, 1L), , ),
bor3(hbz %between% c(-1L, 1L), , ))
expect_equal(or3s(hca %between% c(-1L, 1L), , ),
bor3(hca %between% c(-1L, 1L), , ))
expect_equal(or3s(hcb %between% c(-1L, 1L), , v %between% c(-1L, 1L)),
bor3(hcb %between% c(-1L, 1L), , v %between% c(-1L, 1L)))
expect_equal(or3s(hcc %between% c(-1L, 1L), , f %between% c(-1L, 1L)),
bor3(hcc %between% c(-1L, 1L), , f %between% c(-1L, 1L)))
expect_equal(or3s(hcd %between% c(-1L, 1L), , w %between% c(-1L, 1L)),
bor3(hcd %between% c(-1L, 1L), , w %between% c(-1L, 1L)))
expect_equal(or3s(hce %between% c(-1L, 1L), p > 0L, ),
bor3(hce %between% c(-1L, 1L), p > 0L, ))
expect_equal(or3s(hcf %between% c(-1L, 1L), r > 1L, ),
bor3(hcf %between% c(-1L, 1L), r > 1L, ))
expect_equal(or3s(hcg %between% c(-1L, 1L), s > 9L, ),
bor3(hcg %between% c(-1L, 1L), s > 9L, ))
expect_equal(or3s(hch %between% c(-1L, 1L), s > 0L, c %between% c(-1L, 1L)),
bor3(hch %between% c(-1L, 1L), s > 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(hci %between% c(-1L, 1L), e > 1L, r %between% c(-1L, 1L)),
bor3(hci %between% c(-1L, 1L), e > 1L, r %between% c(-1L, 1L)))
expect_equal(or3s(hcj %between% c(-1L, 1L), b > 9L, b %between% c(-1L, 1L)),
bor3(hcj %between% c(-1L, 1L), b > 9L, b %between% c(-1L, 1L)))
expect_equal(or3s(hck %between% c(-1L, 1L), , ),
bor3(hck %between% c(-1L, 1L), , ))
expect_equal(or3s(hcl %between% c(-1L, 1L), , ),
bor3(hcl %between% c(-1L, 1L), , ))
expect_equal(or3s(hcm %between% c(-1L, 1L), , ),
bor3(hcm %between% c(-1L, 1L), , ))
expect_equal(or3s(hcn %between% c(-1L, 1L), , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hcn %between% c(-1L, 1L), , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hco %between% c(-1L, 1L), , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hco %between% c(-1L, 1L), , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hcp %between% c(-1L, 1L), , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hcp %between% c(-1L, 1L), , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hcq %between% c(-1L, 1L), b > 0L, ),
bor3(hcq %between% c(-1L, 1L), b > 0L, ))
expect_equal(or3s(hcr %between% c(-1L, 1L), i > 1L, ),
bor3(hcr %between% c(-1L, 1L), i > 1L, ))
expect_equal(or3s(hcs %between% c(-1L, 1L), z > 9L, ),
bor3(hcs %between% c(-1L, 1L), z > 9L, ))
expect_equal(or3s(hct %between% c(-1L, 1L), r > 0L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hct %between% c(-1L, 1L), r > 0L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hcu %between% c(-1L, 1L), a > 1L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hcu %between% c(-1L, 1L), a > 1L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hcv %between% c(-1L, 1L), m > 9L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hcv %between% c(-1L, 1L), m > 9L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hcw %between% c(-1L, 1L), , ),
bor3(hcw %between% c(-1L, 1L), , ))
expect_equal(or3s(hcx %between% c(-1L, 1L), , ),
bor3(hcx %between% c(-1L, 1L), , ))
expect_equal(or3s(hcy %between% c(-1L, 1L), , ),
bor3(hcy %between% c(-1L, 1L), , ))
expect_equal(or3s(hcz %between% c(-1L, 1L), , b %in% 1:4),
bor3(hcz %between% c(-1L, 1L), , b %in% 1:4))
expect_equal(or3s(hda %between% c(-1L, 1L), , w %in% 1:4),
bor3(hda %between% c(-1L, 1L), , w %in% 1:4))
expect_equal(or3s(hdb %between% c(-1L, 1L), , c %in% 1:4),
bor3(hdb %between% c(-1L, 1L), , c %in% 1:4))
expect_equal(or3s(hdc %between% c(-1L, 1L), d > 0L, ),
bor3(hdc %between% c(-1L, 1L), d > 0L, ))
expect_equal(or3s(hdd %between% c(-1L, 1L), k > 1L, ),
bor3(hdd %between% c(-1L, 1L), k > 1L, ))
expect_equal(or3s(hde %between% c(-1L, 1L), v > 9L, ),
bor3(hde %between% c(-1L, 1L), v > 9L, ))
expect_equal(or3s(hdf %between% c(-1L, 1L), q > 0L, h %in% 1:4),
bor3(hdf %between% c(-1L, 1L), q > 0L, h %in% 1:4))
expect_equal(or3s(hdg %between% c(-1L, 1L), a > 1L, j %in% 1:4),
bor3(hdg %between% c(-1L, 1L), a > 1L, j %in% 1:4))
expect_equal(or3s(hdh %between% c(-1L, 1L), p > 9L, c %in% 1:4),
bor3(hdh %between% c(-1L, 1L), p > 9L, c %in% 1:4))
expect_equal(or3s(hdi %between% c(-1L, 1L), , ),
bor3(hdi %between% c(-1L, 1L), , ))
expect_equal(or3s(hdj %between% c(-1L, 1L), , ),
bor3(hdj %between% c(-1L, 1L), , ))
expect_equal(or3s(hdk %between% c(-1L, 1L), , ),
bor3(hdk %between% c(-1L, 1L), , ))
expect_equal(or3s(hdl %between% c(-1L, 1L), , j < 0L),
bor3(hdl %between% c(-1L, 1L), , j < 0L))
expect_equal(or3s(hdm %between% c(-1L, 1L), , x < 1L),
bor3(hdm %between% c(-1L, 1L), , x < 1L))
expect_equal(or3s(hdn %between% c(-1L, 1L), , o < 9L),
bor3(hdn %between% c(-1L, 1L), , o < 9L))
expect_equal(or3s(hdo %between% c(-1L, 1L), f > 0L, ),
bor3(hdo %between% c(-1L, 1L), f > 0L, ))
expect_equal(or3s(hdp %between% c(-1L, 1L), v > 1L, ),
bor3(hdp %between% c(-1L, 1L), v > 1L, ))
expect_equal(or3s(hdq %between% c(-1L, 1L), m > 9L, ),
bor3(hdq %between% c(-1L, 1L), m > 9L, ))
expect_equal(or3s(hdr %between% c(-1L, 1L), u > 0L, n < 0L),
bor3(hdr %between% c(-1L, 1L), u > 0L, n < 0L))
expect_equal(or3s(hds %between% c(-1L, 1L), b > 1L, c < 1L),
bor3(hds %between% c(-1L, 1L), b > 1L, c < 1L))
expect_equal(or3s(hdt %between% c(-1L, 1L), o > 9L, u < 9L),
bor3(hdt %between% c(-1L, 1L), o > 9L, u < 9L))
expect_equal(or3s(hdu %between% c(-1L, 1L), , ),
bor3(hdu %between% c(-1L, 1L), , ))
expect_equal(or3s(hdv %between% c(-1L, 1L), , ),
bor3(hdv %between% c(-1L, 1L), , ))
expect_equal(or3s(hdw %between% c(-1L, 1L), , ),
bor3(hdw %between% c(-1L, 1L), , ))
expect_equal(or3s(hdx %between% c(-1L, 1L), , l <= 0L),
bor3(hdx %between% c(-1L, 1L), , l <= 0L))
expect_equal(or3s(hdy %between% c(-1L, 1L), , t <= 1L),
bor3(hdy %between% c(-1L, 1L), , t <= 1L))
expect_equal(or3s(hdz %between% c(-1L, 1L), , u <= 9L),
bor3(hdz %between% c(-1L, 1L), , u <= 9L))
expect_equal(or3s(hea %between% c(-1L, 1L), p > 0L, ),
bor3(hea %between% c(-1L, 1L), p > 0L, ))
expect_equal(or3s(heb %between% c(-1L, 1L), q > 1L, ),
bor3(heb %between% c(-1L, 1L), q > 1L, ))
expect_equal(or3s(hec %between% c(-1L, 1L), k > 9L, ),
bor3(hec %between% c(-1L, 1L), k > 9L, ))
expect_equal(or3s(hed %between% c(-1L, 1L), b > 0L, v <= 0L),
bor3(hed %between% c(-1L, 1L), b > 0L, v <= 0L))
expect_equal(or3s(hee %between% c(-1L, 1L), r > 1L, x <= 1L),
bor3(hee %between% c(-1L, 1L), r > 1L, x <= 1L))
expect_equal(or3s(hef %between% c(-1L, 1L), h > 9L, s <= 9L),
bor3(hef %between% c(-1L, 1L), h > 9L, s <= 9L))
expect_equal(or3s(heg %between% c(-1L, 1L), , ),
bor3(heg %between% c(-1L, 1L), , ))
expect_equal(or3s(heh %between% c(-1L, 1L), , ),
bor3(heh %between% c(-1L, 1L), , ))
expect_equal(or3s(hei %between% c(-1L, 1L), , ),
bor3(hei %between% c(-1L, 1L), , ))
expect_equal(or3s(hej %between% c(-1L, 1L), , h == 0L),
bor3(hej %between% c(-1L, 1L), , h == 0L))
expect_equal(or3s(hek %between% c(-1L, 1L), , h == 1L),
bor3(hek %between% c(-1L, 1L), , h == 1L))
expect_equal(or3s(hel %between% c(-1L, 1L), , j == 9L),
bor3(hel %between% c(-1L, 1L), , j == 9L))
expect_equal(or3s(hem %between% c(-1L, 1L), t > 0L, ),
bor3(hem %between% c(-1L, 1L), t > 0L, ))
expect_equal(or3s(hen %between% c(-1L, 1L), h > 1L, ),
bor3(hen %between% c(-1L, 1L), h > 1L, ))
expect_equal(or3s(heo %between% c(-1L, 1L), d > 9L, ),
bor3(heo %between% c(-1L, 1L), d > 9L, ))
expect_equal(or3s(hep %between% c(-1L, 1L), m > 0L, g == 0L),
bor3(hep %between% c(-1L, 1L), m > 0L, g == 0L))
expect_equal(or3s(heq %between% c(-1L, 1L), r > 1L, v == 1L),
bor3(heq %between% c(-1L, 1L), r > 1L, v == 1L))
expect_equal(or3s(her %between% c(-1L, 1L), u > 9L, g == 9L),
bor3(her %between% c(-1L, 1L), u > 9L, g == 9L))
expect_equal(or3s(hes %between% c(-1L, 1L), , ),
bor3(hes %between% c(-1L, 1L), , ))
expect_equal(or3s(het %between% c(-1L, 1L), , ),
bor3(het %between% c(-1L, 1L), , ))
expect_equal(or3s(heu %between% c(-1L, 1L), , ),
bor3(heu %between% c(-1L, 1L), , ))
expect_equal(or3s(hev %between% c(-1L, 1L), , r > 0L),
bor3(hev %between% c(-1L, 1L), , r > 0L))
expect_equal(or3s(hew %between% c(-1L, 1L), , q > 1L),
bor3(hew %between% c(-1L, 1L), , q > 1L))
expect_equal(or3s(hex %between% c(-1L, 1L), , f > 9L),
bor3(hex %between% c(-1L, 1L), , f > 9L))
expect_equal(or3s(hey %between% c(-1L, 1L), o > 0L, ),
bor3(hey %between% c(-1L, 1L), o > 0L, ))
expect_equal(or3s(hez %between% c(-1L, 1L), p > 1L, ),
bor3(hez %between% c(-1L, 1L), p > 1L, ))
expect_equal(or3s(hfa %between% c(-1L, 1L), w > 9L, ),
bor3(hfa %between% c(-1L, 1L), w > 9L, ))
expect_equal(or3s(hfb %between% c(-1L, 1L), p > 0L, f > 0L),
bor3(hfb %between% c(-1L, 1L), p > 0L, f > 0L))
expect_equal(or3s(hfc %between% c(-1L, 1L), s > 1L, n > 1L),
bor3(hfc %between% c(-1L, 1L), s > 1L, n > 1L))
expect_equal(or3s(hfd %between% c(-1L, 1L), f > 9L, o > 9L),
bor3(hfd %between% c(-1L, 1L), f > 9L, o > 9L))
expect_equal(or3s(hfe %between% c(-1L, 1L), , ),
bor3(hfe %between% c(-1L, 1L), , ))
expect_equal(or3s(hff %between% c(-1L, 1L), , ),
bor3(hff %between% c(-1L, 1L), , ))
expect_equal(or3s(hfg %between% c(-1L, 1L), , ),
bor3(hfg %between% c(-1L, 1L), , ))
expect_equal(or3s(hfh %between% c(-1L, 1L), , o >= 0L),
bor3(hfh %between% c(-1L, 1L), , o >= 0L))
expect_equal(or3s(hfi %between% c(-1L, 1L), , a >= 1L),
bor3(hfi %between% c(-1L, 1L), , a >= 1L))
expect_equal(or3s(hfj %between% c(-1L, 1L), , g >= 9L),
bor3(hfj %between% c(-1L, 1L), , g >= 9L))
expect_equal(or3s(hfk %between% c(-1L, 1L), u > 0L, ),
bor3(hfk %between% c(-1L, 1L), u > 0L, ))
expect_equal(or3s(hfl %between% c(-1L, 1L), u > 1L, ),
bor3(hfl %between% c(-1L, 1L), u > 1L, ))
expect_equal(or3s(hfm %between% c(-1L, 1L), w > 9L, ),
bor3(hfm %between% c(-1L, 1L), w > 9L, ))
expect_equal(or3s(hfn %between% c(-1L, 1L), c > 0L, r >= 0L),
bor3(hfn %between% c(-1L, 1L), c > 0L, r >= 0L))
expect_equal(or3s(hfo %between% c(-1L, 1L), b > 1L, q >= 1L),
bor3(hfo %between% c(-1L, 1L), b > 1L, q >= 1L))
expect_equal(or3s(hfp %between% c(-1L, 1L), k > 9L, u >= 9L),
bor3(hfp %between% c(-1L, 1L), k > 9L, u >= 9L))
expect_equal(or3s(hfq %between% c(-1L, 1L), , ),
bor3(hfq %between% c(-1L, 1L), , ))
expect_equal(or3s(hfr %between% c(-1L, 1L), , ),
bor3(hfr %between% c(-1L, 1L), , ))
expect_equal(or3s(hfs %between% c(-1L, 1L), , ),
bor3(hfs %between% c(-1L, 1L), , ))
expect_equal(or3s(hft %between% c(-1L, 1L), , logi_a),
bor3(hft %between% c(-1L, 1L), , logi_a))
expect_equal(or3s(hfu %between% c(-1L, 1L), , logi_u),
bor3(hfu %between% c(-1L, 1L), , logi_u))
expect_equal(or3s(hfv %between% c(-1L, 1L), , logi_o),
bor3(hfv %between% c(-1L, 1L), , logi_o))
expect_equal(or3s(hfw %between% c(-1L, 1L), l >= 0L, ),
bor3(hfw %between% c(-1L, 1L), l >= 0L, ))
expect_equal(or3s(hfx %between% c(-1L, 1L), i >= 1L, ),
bor3(hfx %between% c(-1L, 1L), i >= 1L, ))
expect_equal(or3s(hfy %between% c(-1L, 1L), l >= 9L, ),
bor3(hfy %between% c(-1L, 1L), l >= 9L, ))
expect_equal(or3s(hfz %between% c(-1L, 1L), w >= 0L, logi_g),
bor3(hfz %between% c(-1L, 1L), w >= 0L, logi_g))
expect_equal(or3s(hga %between% c(-1L, 1L), k >= 1L, logi_j),
bor3(hga %between% c(-1L, 1L), k >= 1L, logi_j))
expect_equal(or3s(hgb %between% c(-1L, 1L), p >= 9L, logi_k),
bor3(hgb %between% c(-1L, 1L), p >= 9L, logi_k))
expect_equal(or3s(hgc %between% c(-1L, 1L), , ),
bor3(hgc %between% c(-1L, 1L), , ))
expect_equal(or3s(hgd %between% c(-1L, 1L), , ),
bor3(hgd %between% c(-1L, 1L), , ))
expect_equal(or3s(hge %between% c(-1L, 1L), , ),
bor3(hge %between% c(-1L, 1L), , ))
expect_equal(or3s(hgf %between% c(-1L, 1L), , !logi_t),
bor3(hgf %between% c(-1L, 1L), , !logi_t))
expect_equal(or3s(hgg %between% c(-1L, 1L), , !logi_s),
bor3(hgg %between% c(-1L, 1L), , !logi_s))
expect_equal(or3s(hgh %between% c(-1L, 1L), , !logi_y),
bor3(hgh %between% c(-1L, 1L), , !logi_y))
expect_equal(or3s(hgi %between% c(-1L, 1L), d >= 0L, ),
bor3(hgi %between% c(-1L, 1L), d >= 0L, ))
expect_equal(or3s(hgj %between% c(-1L, 1L), h >= 1L, ),
bor3(hgj %between% c(-1L, 1L), h >= 1L, ))
expect_equal(or3s(hgk %between% c(-1L, 1L), q >= 9L, ),
bor3(hgk %between% c(-1L, 1L), q >= 9L, ))
expect_equal(or3s(hgl %between% c(-1L, 1L), o >= 0L, !logi_v),
bor3(hgl %between% c(-1L, 1L), o >= 0L, !logi_v))
expect_equal(or3s(hgm %between% c(-1L, 1L), f >= 1L, !logi_h),
bor3(hgm %between% c(-1L, 1L), f >= 1L, !logi_h))
expect_equal(or3s(hgn %between% c(-1L, 1L), h >= 9L, !logi_g),
bor3(hgn %between% c(-1L, 1L), h >= 9L, !logi_g))
expect_equal(or3s(hgo %between% c(-1L, 1L), , ),
bor3(hgo %between% c(-1L, 1L), , ))
expect_equal(or3s(hgp %between% c(-1L, 1L), , ),
bor3(hgp %between% c(-1L, 1L), , ))
expect_equal(or3s(hgq %between% c(-1L, 1L), , ),
bor3(hgq %between% c(-1L, 1L), , ))
expect_equal(or3s(hgr %between% c(-1L, 1L), , u != 0L),
bor3(hgr %between% c(-1L, 1L), , u != 0L))
expect_equal(or3s(hgs %between% c(-1L, 1L), , h != 1L),
bor3(hgs %between% c(-1L, 1L), , h != 1L))
expect_equal(or3s(hgt %between% c(-1L, 1L), , z != 9L),
bor3(hgt %between% c(-1L, 1L), , z != 9L))
expect_equal(or3s(hgu %between% c(-1L, 1L), k >= 0L, ),
bor3(hgu %between% c(-1L, 1L), k >= 0L, ))
expect_equal(or3s(hgv %between% c(-1L, 1L), b >= 1L, ),
bor3(hgv %between% c(-1L, 1L), b >= 1L, ))
expect_equal(or3s(hgw %between% c(-1L, 1L), k >= 9L, ),
bor3(hgw %between% c(-1L, 1L), k >= 9L, ))
expect_equal(or3s(hgx %between% c(-1L, 1L), l >= 0L, r != 0L),
bor3(hgx %between% c(-1L, 1L), l >= 0L, r != 0L))
expect_equal(or3s(hgy %between% c(-1L, 1L), q >= 1L, y != 1L),
bor3(hgy %between% c(-1L, 1L), q >= 1L, y != 1L))
expect_equal(or3s(hgz %between% c(-1L, 1L), s >= 9L, u != 9L),
bor3(hgz %between% c(-1L, 1L), s >= 9L, u != 9L))
expect_equal(or3s(hha %between% c(-1L, 1L), , ),
bor3(hha %between% c(-1L, 1L), , ))
expect_equal(or3s(hhb %between% c(-1L, 1L), , ),
bor3(hhb %between% c(-1L, 1L), , ))
expect_equal(or3s(hhc %between% c(-1L, 1L), , ),
bor3(hhc %between% c(-1L, 1L), , ))
expect_equal(or3s(hhd %between% c(-1L, 1L), , f %between% c(-1L, 1L)),
bor3(hhd %between% c(-1L, 1L), , f %between% c(-1L, 1L)))
expect_equal(or3s(hhe %between% c(-1L, 1L), , y %between% c(-1L, 1L)),
bor3(hhe %between% c(-1L, 1L), , y %between% c(-1L, 1L)))
expect_equal(or3s(hhf %between% c(-1L, 1L), , v %between% c(-1L, 1L)),
bor3(hhf %between% c(-1L, 1L), , v %between% c(-1L, 1L)))
expect_equal(or3s(hhg %between% c(-1L, 1L), i >= 0L, ),
bor3(hhg %between% c(-1L, 1L), i >= 0L, ))
expect_equal(or3s(hhh %between% c(-1L, 1L), s >= 1L, ),
bor3(hhh %between% c(-1L, 1L), s >= 1L, ))
expect_equal(or3s(hhi %between% c(-1L, 1L), g >= 9L, ),
bor3(hhi %between% c(-1L, 1L), g >= 9L, ))
expect_equal(or3s(hhj %between% c(-1L, 1L), j >= 0L, y %between% c(-1L, 1L)),
bor3(hhj %between% c(-1L, 1L), j >= 0L, y %between% c(-1L, 1L)))
expect_equal(or3s(hhk %between% c(-1L, 1L), g >= 1L, q %between% c(-1L, 1L)),
bor3(hhk %between% c(-1L, 1L), g >= 1L, q %between% c(-1L, 1L)))
expect_equal(or3s(hhl %between% c(-1L, 1L), u >= 9L, k %between% c(-1L, 1L)),
bor3(hhl %between% c(-1L, 1L), u >= 9L, k %between% c(-1L, 1L)))
expect_equal(or3s(hhm %between% c(-1L, 1L), , ),
bor3(hhm %between% c(-1L, 1L), , ))
expect_equal(or3s(hhn %between% c(-1L, 1L), , ),
bor3(hhn %between% c(-1L, 1L), , ))
expect_equal(or3s(hho %between% c(-1L, 1L), , ),
bor3(hho %between% c(-1L, 1L), , ))
expect_equal(or3s(hhp %between% c(-1L, 1L), , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hhp %between% c(-1L, 1L), , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hhq %between% c(-1L, 1L), , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hhq %between% c(-1L, 1L), , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hhr %between% c(-1L, 1L), , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hhr %between% c(-1L, 1L), , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hhs %between% c(-1L, 1L), h >= 0L, ),
bor3(hhs %between% c(-1L, 1L), h >= 0L, ))
expect_equal(or3s(hht %between% c(-1L, 1L), z >= 1L, ),
bor3(hht %between% c(-1L, 1L), z >= 1L, ))
expect_equal(or3s(hhu %between% c(-1L, 1L), j >= 9L, ),
bor3(hhu %between% c(-1L, 1L), j >= 9L, ))
expect_equal(or3s(hhv %between% c(-1L, 1L), g >= 0L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hhv %between% c(-1L, 1L), g >= 0L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hhw %between% c(-1L, 1L), v >= 1L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hhw %between% c(-1L, 1L), v >= 1L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hhx %between% c(-1L, 1L), d >= 9L, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hhx %between% c(-1L, 1L), d >= 9L, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hhy %between% c(-1L, 1L), , ),
bor3(hhy %between% c(-1L, 1L), , ))
expect_equal(or3s(hhz %between% c(-1L, 1L), , ),
bor3(hhz %between% c(-1L, 1L), , ))
expect_equal(or3s(hia %between% c(-1L, 1L), , ),
bor3(hia %between% c(-1L, 1L), , ))
expect_equal(or3s(hib %between% c(-1L, 1L), , b %in% 1:4),
bor3(hib %between% c(-1L, 1L), , b %in% 1:4))
expect_equal(or3s(hic %between% c(-1L, 1L), , t %in% 1:4),
bor3(hic %between% c(-1L, 1L), , t %in% 1:4))
expect_equal(or3s(hid %between% c(-1L, 1L), , t %in% 1:4),
bor3(hid %between% c(-1L, 1L), , t %in% 1:4))
expect_equal(or3s(hie %between% c(-1L, 1L), r >= 0L, ),
bor3(hie %between% c(-1L, 1L), r >= 0L, ))
expect_equal(or3s(hif %between% c(-1L, 1L), a >= 1L, ),
bor3(hif %between% c(-1L, 1L), a >= 1L, ))
expect_equal(or3s(hig %between% c(-1L, 1L), s >= 9L, ),
bor3(hig %between% c(-1L, 1L), s >= 9L, ))
expect_equal(or3s(hih %between% c(-1L, 1L), e >= 0L, z %in% 1:4),
bor3(hih %between% c(-1L, 1L), e >= 0L, z %in% 1:4))
expect_equal(or3s(hii %between% c(-1L, 1L), r >= 1L, f %in% 1:4),
bor3(hii %between% c(-1L, 1L), r >= 1L, f %in% 1:4))
expect_equal(or3s(hij %between% c(-1L, 1L), i >= 9L, m %in% 1:4),
bor3(hij %between% c(-1L, 1L), i >= 9L, m %in% 1:4))
expect_equal(or3s(hik %between% c(-1L, 1L), , ),
bor3(hik %between% c(-1L, 1L), , ))
expect_equal(or3s(hil %between% c(-1L, 1L), , ),
bor3(hil %between% c(-1L, 1L), , ))
expect_equal(or3s(him %between% c(-1L, 1L), , ),
bor3(him %between% c(-1L, 1L), , ))
expect_equal(or3s(hin %between% c(-1L, 1L), , f < 0L),
bor3(hin %between% c(-1L, 1L), , f < 0L))
expect_equal(or3s(hio %between% c(-1L, 1L), , d < 1L),
bor3(hio %between% c(-1L, 1L), , d < 1L))
expect_equal(or3s(hip %between% c(-1L, 1L), , h < 9L),
bor3(hip %between% c(-1L, 1L), , h < 9L))
expect_equal(or3s(hiq %between% c(-1L, 1L), r >= 0L, ),
bor3(hiq %between% c(-1L, 1L), r >= 0L, ))
expect_equal(or3s(hir %between% c(-1L, 1L), s >= 1L, ),
bor3(hir %between% c(-1L, 1L), s >= 1L, ))
expect_equal(or3s(his %between% c(-1L, 1L), f >= 9L, ),
bor3(his %between% c(-1L, 1L), f >= 9L, ))
expect_equal(or3s(hit %between% c(-1L, 1L), x >= 0L, r < 0L),
bor3(hit %between% c(-1L, 1L), x >= 0L, r < 0L))
expect_equal(or3s(hiu %between% c(-1L, 1L), u >= 1L, s < 1L),
bor3(hiu %between% c(-1L, 1L), u >= 1L, s < 1L))
expect_equal(or3s(hiv %between% c(-1L, 1L), o >= 9L, u < 9L),
bor3(hiv %between% c(-1L, 1L), o >= 9L, u < 9L))
expect_equal(or3s(hiw %between% c(-1L, 1L), , ),
bor3(hiw %between% c(-1L, 1L), , ))
expect_equal(or3s(hix %between% c(-1L, 1L), , ),
bor3(hix %between% c(-1L, 1L), , ))
expect_equal(or3s(hiy %between% c(-1L, 1L), , ),
bor3(hiy %between% c(-1L, 1L), , ))
expect_equal(or3s(hiz %between% c(-1L, 1L), , g <= 0L),
bor3(hiz %between% c(-1L, 1L), , g <= 0L))
expect_equal(or3s(hja %between% c(-1L, 1L), , k <= 1L),
bor3(hja %between% c(-1L, 1L), , k <= 1L))
expect_equal(or3s(hjb %between% c(-1L, 1L), , b <= 9L),
bor3(hjb %between% c(-1L, 1L), , b <= 9L))
expect_equal(or3s(hjc %between% c(-1L, 1L), p >= 0L, ),
bor3(hjc %between% c(-1L, 1L), p >= 0L, ))
expect_equal(or3s(hjd %between% c(-1L, 1L), f >= 1L, ),
bor3(hjd %between% c(-1L, 1L), f >= 1L, ))
expect_equal(or3s(hje %between% c(-1L, 1L), a >= 9L, ),
bor3(hje %between% c(-1L, 1L), a >= 9L, ))
expect_equal(or3s(hjf %between% c(-1L, 1L), s >= 0L, p <= 0L),
bor3(hjf %between% c(-1L, 1L), s >= 0L, p <= 0L))
expect_equal(or3s(hjg %between% c(-1L, 1L), u >= 1L, b <= 1L),
bor3(hjg %between% c(-1L, 1L), u >= 1L, b <= 1L))
expect_equal(or3s(hjh %between% c(-1L, 1L), z >= 9L, s <= 9L),
bor3(hjh %between% c(-1L, 1L), z >= 9L, s <= 9L))
expect_equal(or3s(hji %between% c(-1L, 1L), , ),
bor3(hji %between% c(-1L, 1L), , ))
expect_equal(or3s(hjj %between% c(-1L, 1L), , ),
bor3(hjj %between% c(-1L, 1L), , ))
expect_equal(or3s(hjk %between% c(-1L, 1L), , ),
bor3(hjk %between% c(-1L, 1L), , ))
expect_equal(or3s(hjl %between% c(-1L, 1L), , e == 0L),
bor3(hjl %between% c(-1L, 1L), , e == 0L))
expect_equal(or3s(hjm %between% c(-1L, 1L), , d == 1L),
bor3(hjm %between% c(-1L, 1L), , d == 1L))
expect_equal(or3s(hjn %between% c(-1L, 1L), , c == 9L),
bor3(hjn %between% c(-1L, 1L), , c == 9L))
expect_equal(or3s(hjo %between% c(-1L, 1L), h >= 0L, ),
bor3(hjo %between% c(-1L, 1L), h >= 0L, ))
expect_equal(or3s(hjp %between% c(-1L, 1L), k >= 1L, ),
bor3(hjp %between% c(-1L, 1L), k >= 1L, ))
expect_equal(or3s(hjq %between% c(-1L, 1L), i >= 9L, ),
bor3(hjq %between% c(-1L, 1L), i >= 9L, ))
expect_equal(or3s(hjr %between% c(-1L, 1L), o >= 0L, r == 0L),
bor3(hjr %between% c(-1L, 1L), o >= 0L, r == 0L))
expect_equal(or3s(hjs %between% c(-1L, 1L), y >= 1L, u == 1L),
bor3(hjs %between% c(-1L, 1L), y >= 1L, u == 1L))
expect_equal(or3s(hjt %between% c(-1L, 1L), z >= 9L, e == 9L),
bor3(hjt %between% c(-1L, 1L), z >= 9L, e == 9L))
expect_equal(or3s(hju %between% c(-1L, 1L), , ),
bor3(hju %between% c(-1L, 1L), , ))
expect_equal(or3s(hjv %between% c(-1L, 1L), , ),
bor3(hjv %between% c(-1L, 1L), , ))
expect_equal(or3s(hjw %between% c(-1L, 1L), , ),
bor3(hjw %between% c(-1L, 1L), , ))
expect_equal(or3s(hjx %between% c(-1L, 1L), , o > 0L),
bor3(hjx %between% c(-1L, 1L), , o > 0L))
expect_equal(or3s(hjy %between% c(-1L, 1L), , p > 1L),
bor3(hjy %between% c(-1L, 1L), , p > 1L))
expect_equal(or3s(hjz %between% c(-1L, 1L), , b > 9L),
bor3(hjz %between% c(-1L, 1L), , b > 9L))
expect_equal(or3s(hka %between% c(-1L, 1L), s >= 0L, ),
bor3(hka %between% c(-1L, 1L), s >= 0L, ))
expect_equal(or3s(hkb %between% c(-1L, 1L), g >= 1L, ),
bor3(hkb %between% c(-1L, 1L), g >= 1L, ))
expect_equal(or3s(hkc %between% c(-1L, 1L), y >= 9L, ),
bor3(hkc %between% c(-1L, 1L), y >= 9L, ))
expect_equal(or3s(hkd %between% c(-1L, 1L), d >= 0L, a > 0L),
bor3(hkd %between% c(-1L, 1L), d >= 0L, a > 0L))
expect_equal(or3s(hke %between% c(-1L, 1L), h >= 1L, p > 1L),
bor3(hke %between% c(-1L, 1L), h >= 1L, p > 1L))
expect_equal(or3s(hkf %between% c(-1L, 1L), z >= 9L, g > 9L),
bor3(hkf %between% c(-1L, 1L), z >= 9L, g > 9L))
expect_equal(or3s(hkg %between% c(-1L, 1L), , ),
bor3(hkg %between% c(-1L, 1L), , ))
expect_equal(or3s(hkh %between% c(-1L, 1L), , ),
bor3(hkh %between% c(-1L, 1L), , ))
expect_equal(or3s(hki %between% c(-1L, 1L), , ),
bor3(hki %between% c(-1L, 1L), , ))
expect_equal(or3s(hkj %between% c(-1L, 1L), , i >= 0L),
bor3(hkj %between% c(-1L, 1L), , i >= 0L))
expect_equal(or3s(hkk %between% c(-1L, 1L), , g >= 1L),
bor3(hkk %between% c(-1L, 1L), , g >= 1L))
expect_equal(or3s(hkl %between% c(-1L, 1L), , n >= 9L),
bor3(hkl %between% c(-1L, 1L), , n >= 9L))
expect_equal(or3s(hkm %between% c(-1L, 1L), s >= 0L, ),
bor3(hkm %between% c(-1L, 1L), s >= 0L, ))
expect_equal(or3s(hkn %between% c(-1L, 1L), s >= 1L, ),
bor3(hkn %between% c(-1L, 1L), s >= 1L, ))
expect_equal(or3s(hko %between% c(-1L, 1L), o >= 9L, ),
bor3(hko %between% c(-1L, 1L), o >= 9L, ))
expect_equal(or3s(hkp %between% c(-1L, 1L), c >= 0L, l >= 0L),
bor3(hkp %between% c(-1L, 1L), c >= 0L, l >= 0L))
expect_equal(or3s(hkq %between% c(-1L, 1L), e >= 1L, o >= 1L),
bor3(hkq %between% c(-1L, 1L), e >= 1L, o >= 1L))
expect_equal(or3s(hkr %between% c(-1L, 1L), c >= 9L, f >= 9L),
bor3(hkr %between% c(-1L, 1L), c >= 9L, f >= 9L))
expect_equal(or3s(hks %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hks %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hkt %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hkt %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hku %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hku %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hkv %in% c(4L, -3L, 2L, 7L, 8L), , logi_k),
bor3(hkv %in% c(4L, -3L, 2L, 7L, 8L), , logi_k))
expect_equal(or3s(hkw %in% c(4L, -3L, 2L, 7L, 8L), , logi_e),
bor3(hkw %in% c(4L, -3L, 2L, 7L, 8L), , logi_e))
expect_equal(or3s(hkx %in% c(4L, -3L, 2L, 7L, 8L), , logi_g),
bor3(hkx %in% c(4L, -3L, 2L, 7L, 8L), , logi_g))
expect_equal(or3s(hky %in% c(4L, -3L, 2L, 7L, 8L), logi_q, ),
bor3(hky %in% c(4L, -3L, 2L, 7L, 8L), logi_q, ))
expect_equal(or3s(hkz %in% c(4L, -3L, 2L, 7L, 8L), logi_a, ),
bor3(hkz %in% c(4L, -3L, 2L, 7L, 8L), logi_a, ))
expect_equal(or3s(hla %in% c(4L, -3L, 2L, 7L, 8L), logi_z, ),
bor3(hla %in% c(4L, -3L, 2L, 7L, 8L), logi_z, ))
expect_equal(or3s(hlb %in% c(4L, -3L, 2L, 7L, 8L), logi_h, logi_n),
bor3(hlb %in% c(4L, -3L, 2L, 7L, 8L), logi_h, logi_n))
expect_equal(or3s(hlc %in% c(4L, -3L, 2L, 7L, 8L), logi_c, logi_i),
bor3(hlc %in% c(4L, -3L, 2L, 7L, 8L), logi_c, logi_i))
expect_equal(or3s(hld %in% c(4L, -3L, 2L, 7L, 8L), logi_i, logi_c),
bor3(hld %in% c(4L, -3L, 2L, 7L, 8L), logi_i, logi_c))
expect_equal(or3s(hle %in% 1:4, , ),
bor3(hle %in% 1:4, , ))
expect_equal(or3s(hlf %in% 1:4, , ),
bor3(hlf %in% 1:4, , ))
expect_equal(or3s(hlg %in% 1:4, , ),
bor3(hlg %in% 1:4, , ))
expect_equal(or3s(hlh %in% 1:4, , logi_v),
bor3(hlh %in% 1:4, , logi_v))
expect_equal(or3s(hli %in% 1:4, , logi_g),
bor3(hli %in% 1:4, , logi_g))
expect_equal(or3s(hlj %in% 1:4, , logi_y),
bor3(hlj %in% 1:4, , logi_y))
expect_equal(or3s(hlk %in% 1:4, logi_u, ),
bor3(hlk %in% 1:4, logi_u, ))
expect_equal(or3s(hll %in% 1:4, logi_r, ),
bor3(hll %in% 1:4, logi_r, ))
expect_equal(or3s(hlm %in% 1:4, logi_x, ),
bor3(hlm %in% 1:4, logi_x, ))
expect_equal(or3s(hln %in% 1:4, logi_u, logi_y),
bor3(hln %in% 1:4, logi_u, logi_y))
expect_equal(or3s(hlo %in% 1:4, logi_z, logi_l),
bor3(hlo %in% 1:4, logi_z, logi_l))
expect_equal(or3s(hlp %in% 1:4, logi_m, logi_p),
bor3(hlp %in% 1:4, logi_m, logi_p))
expect_equal(or3s(hlq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hlq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hlr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hlr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hls %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hls %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hlt %in% c(4L, -3L, 2L, 7L, 8L), , !logi_u),
bor3(hlt %in% c(4L, -3L, 2L, 7L, 8L), , !logi_u))
expect_equal(or3s(hlu %in% c(4L, -3L, 2L, 7L, 8L), , !logi_r),
bor3(hlu %in% c(4L, -3L, 2L, 7L, 8L), , !logi_r))
expect_equal(or3s(hlv %in% c(4L, -3L, 2L, 7L, 8L), , !logi_e),
bor3(hlv %in% c(4L, -3L, 2L, 7L, 8L), , !logi_e))
expect_equal(or3s(hlw %in% c(4L, -3L, 2L, 7L, 8L), logi_j, ),
bor3(hlw %in% c(4L, -3L, 2L, 7L, 8L), logi_j, ))
expect_equal(or3s(hlx %in% c(4L, -3L, 2L, 7L, 8L), logi_h, ),
bor3(hlx %in% c(4L, -3L, 2L, 7L, 8L), logi_h, ))
expect_equal(or3s(hly %in% c(4L, -3L, 2L, 7L, 8L), logi_a, ),
bor3(hly %in% c(4L, -3L, 2L, 7L, 8L), logi_a, ))
expect_equal(or3s(hlz %in% c(4L, -3L, 2L, 7L, 8L), logi_b, !logi_d),
bor3(hlz %in% c(4L, -3L, 2L, 7L, 8L), logi_b, !logi_d))
expect_equal(or3s(hma %in% c(4L, -3L, 2L, 7L, 8L), logi_r, !logi_m),
bor3(hma %in% c(4L, -3L, 2L, 7L, 8L), logi_r, !logi_m))
expect_equal(or3s(hmb %in% c(4L, -3L, 2L, 7L, 8L), logi_h, !logi_q),
bor3(hmb %in% c(4L, -3L, 2L, 7L, 8L), logi_h, !logi_q))
expect_equal(or3s(hmc %in% 1:4, , ),
bor3(hmc %in% 1:4, , ))
expect_equal(or3s(hmd %in% 1:4, , ),
bor3(hmd %in% 1:4, , ))
expect_equal(or3s(hme %in% 1:4, , ),
bor3(hme %in% 1:4, , ))
expect_equal(or3s(hmf %in% 1:4, , !logi_x),
bor3(hmf %in% 1:4, , !logi_x))
expect_equal(or3s(hmg %in% 1:4, , !logi_t),
bor3(hmg %in% 1:4, , !logi_t))
expect_equal(or3s(hmh %in% 1:4, , !logi_x),
bor3(hmh %in% 1:4, , !logi_x))
expect_equal(or3s(hmi %in% 1:4, logi_r, ),
bor3(hmi %in% 1:4, logi_r, ))
expect_equal(or3s(hmj %in% 1:4, logi_m, ),
bor3(hmj %in% 1:4, logi_m, ))
expect_equal(or3s(hmk %in% 1:4, logi_f, ),
bor3(hmk %in% 1:4, logi_f, ))
expect_equal(or3s(hml %in% 1:4, logi_t, !logi_t),
bor3(hml %in% 1:4, logi_t, !logi_t))
expect_equal(or3s(hmm %in% 1:4, logi_a, !logi_g),
bor3(hmm %in% 1:4, logi_a, !logi_g))
expect_equal(or3s(hmn %in% 1:4, logi_f, !logi_r),
bor3(hmn %in% 1:4, logi_f, !logi_r))
expect_equal(or3s(hmo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hmo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hmp %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hmp %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hmq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hmq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hmr %in% c(4L, -3L, 2L, 7L, 8L), , m != 0L),
bor3(hmr %in% c(4L, -3L, 2L, 7L, 8L), , m != 0L))
expect_equal(or3s(hms %in% c(4L, -3L, 2L, 7L, 8L), , d != 1L),
bor3(hms %in% c(4L, -3L, 2L, 7L, 8L), , d != 1L))
expect_equal(or3s(hmt %in% c(4L, -3L, 2L, 7L, 8L), , n != 9L),
bor3(hmt %in% c(4L, -3L, 2L, 7L, 8L), , n != 9L))
expect_equal(or3s(hmu %in% c(4L, -3L, 2L, 7L, 8L), logi_g, ),
bor3(hmu %in% c(4L, -3L, 2L, 7L, 8L), logi_g, ))
expect_equal(or3s(hmv %in% c(4L, -3L, 2L, 7L, 8L), logi_s, ),
bor3(hmv %in% c(4L, -3L, 2L, 7L, 8L), logi_s, ))
expect_equal(or3s(hmw %in% c(4L, -3L, 2L, 7L, 8L), logi_e, ),
bor3(hmw %in% c(4L, -3L, 2L, 7L, 8L), logi_e, ))
expect_equal(or3s(hmx %in% c(4L, -3L, 2L, 7L, 8L), logi_a, s != 0L),
bor3(hmx %in% c(4L, -3L, 2L, 7L, 8L), logi_a, s != 0L))
expect_equal(or3s(hmy %in% c(4L, -3L, 2L, 7L, 8L), logi_x, j != 1L),
bor3(hmy %in% c(4L, -3L, 2L, 7L, 8L), logi_x, j != 1L))
expect_equal(or3s(hmz %in% c(4L, -3L, 2L, 7L, 8L), logi_j, g != 9L),
bor3(hmz %in% c(4L, -3L, 2L, 7L, 8L), logi_j, g != 9L))
expect_equal(or3s(hna %in% 1:4, , ),
bor3(hna %in% 1:4, , ))
expect_equal(or3s(hnb %in% 1:4, , ),
bor3(hnb %in% 1:4, , ))
expect_equal(or3s(hnc %in% 1:4, , ),
bor3(hnc %in% 1:4, , ))
expect_equal(or3s(hnd %in% 1:4, , k != 0L),
bor3(hnd %in% 1:4, , k != 0L))
expect_equal(or3s(hne %in% 1:4, , u != 1L),
bor3(hne %in% 1:4, , u != 1L))
expect_equal(or3s(hnf %in% 1:4, , i != 9L),
bor3(hnf %in% 1:4, , i != 9L))
expect_equal(or3s(hng %in% 1:4, logi_y, ),
bor3(hng %in% 1:4, logi_y, ))
expect_equal(or3s(hnh %in% 1:4, logi_j, ),
bor3(hnh %in% 1:4, logi_j, ))
expect_equal(or3s(hni %in% 1:4, logi_y, ),
bor3(hni %in% 1:4, logi_y, ))
expect_equal(or3s(hnj %in% 1:4, logi_j, n != 0L),
bor3(hnj %in% 1:4, logi_j, n != 0L))
expect_equal(or3s(hnk %in% 1:4, logi_i, o != 1L),
bor3(hnk %in% 1:4, logi_i, o != 1L))
expect_equal(or3s(hnl %in% 1:4, logi_x, h != 9L),
bor3(hnl %in% 1:4, logi_x, h != 9L))
expect_equal(or3s(hnm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hnm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hnn %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hnn %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hno %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hno %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hnp %in% c(4L, -3L, 2L, 7L, 8L), , l %between% c(-1L, 1L)),
bor3(hnp %in% c(4L, -3L, 2L, 7L, 8L), , l %between% c(-1L, 1L)))
expect_equal(or3s(hnq %in% c(4L, -3L, 2L, 7L, 8L), , d %between% c(-1L, 1L)),
bor3(hnq %in% c(4L, -3L, 2L, 7L, 8L), , d %between% c(-1L, 1L)))
expect_equal(or3s(hnr %in% c(4L, -3L, 2L, 7L, 8L), , c %between% c(-1L, 1L)),
bor3(hnr %in% c(4L, -3L, 2L, 7L, 8L), , c %between% c(-1L, 1L)))
expect_equal(or3s(hns %in% c(4L, -3L, 2L, 7L, 8L), logi_m, ),
bor3(hns %in% c(4L, -3L, 2L, 7L, 8L), logi_m, ))
expect_equal(or3s(hnt %in% c(4L, -3L, 2L, 7L, 8L), logi_p, ),
bor3(hnt %in% c(4L, -3L, 2L, 7L, 8L), logi_p, ))
expect_equal(or3s(hnu %in% c(4L, -3L, 2L, 7L, 8L), logi_f, ),
bor3(hnu %in% c(4L, -3L, 2L, 7L, 8L), logi_f, ))
expect_equal(or3s(hnv %in% c(4L, -3L, 2L, 7L, 8L), logi_k, q %between% c(-1L, 1L)),
bor3(hnv %in% c(4L, -3L, 2L, 7L, 8L), logi_k, q %between% c(-1L, 1L)))
expect_equal(or3s(hnw %in% c(4L, -3L, 2L, 7L, 8L), logi_r, h %between% c(-1L, 1L)),
bor3(hnw %in% c(4L, -3L, 2L, 7L, 8L), logi_r, h %between% c(-1L, 1L)))
expect_equal(or3s(hnx %in% c(4L, -3L, 2L, 7L, 8L), logi_f, d %between% c(-1L, 1L)),
bor3(hnx %in% c(4L, -3L, 2L, 7L, 8L), logi_f, d %between% c(-1L, 1L)))
expect_equal(or3s(hny %in% 1:4, , ),
bor3(hny %in% 1:4, , ))
expect_equal(or3s(hnz %in% 1:4, , ),
bor3(hnz %in% 1:4, , ))
expect_equal(or3s(hoa %in% 1:4, , ),
bor3(hoa %in% 1:4, , ))
expect_equal(or3s(hob %in% 1:4, , w %between% c(-1L, 1L)),
bor3(hob %in% 1:4, , w %between% c(-1L, 1L)))
expect_equal(or3s(hoc %in% 1:4, , r %between% c(-1L, 1L)),
bor3(hoc %in% 1:4, , r %between% c(-1L, 1L)))
expect_equal(or3s(hod %in% 1:4, , c %between% c(-1L, 1L)),
bor3(hod %in% 1:4, , c %between% c(-1L, 1L)))
expect_equal(or3s(hoe %in% 1:4, logi_b, ),
bor3(hoe %in% 1:4, logi_b, ))
expect_equal(or3s(hof %in% 1:4, logi_t, ),
bor3(hof %in% 1:4, logi_t, ))
expect_equal(or3s(hog %in% 1:4, logi_o, ),
bor3(hog %in% 1:4, logi_o, ))
expect_equal(or3s(hoh %in% 1:4, logi_f, a %between% c(-1L, 1L)),
bor3(hoh %in% 1:4, logi_f, a %between% c(-1L, 1L)))
expect_equal(or3s(hoi %in% 1:4, logi_k, e %between% c(-1L, 1L)),
bor3(hoi %in% 1:4, logi_k, e %between% c(-1L, 1L)))
expect_equal(or3s(hoj %in% 1:4, logi_k, q %between% c(-1L, 1L)),
bor3(hoj %in% 1:4, logi_k, q %between% c(-1L, 1L)))
expect_equal(or3s(hok %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hok %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hol %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hol %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hom %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hom %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hon %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hon %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hoo %in% c(4L, -3L, 2L, 7L, 8L), , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hoo %in% c(4L, -3L, 2L, 7L, 8L), , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hop %in% c(4L, -3L, 2L, 7L, 8L), , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hop %in% c(4L, -3L, 2L, 7L, 8L), , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hoq %in% c(4L, -3L, 2L, 7L, 8L), logi_h, ),
bor3(hoq %in% c(4L, -3L, 2L, 7L, 8L), logi_h, ))
expect_equal(or3s(hor %in% c(4L, -3L, 2L, 7L, 8L), logi_x, ),
bor3(hor %in% c(4L, -3L, 2L, 7L, 8L), logi_x, ))
expect_equal(or3s(hos %in% c(4L, -3L, 2L, 7L, 8L), logi_s, ),
bor3(hos %in% c(4L, -3L, 2L, 7L, 8L), logi_s, ))
expect_equal(or3s(hot %in% c(4L, -3L, 2L, 7L, 8L), logi_w, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hot %in% c(4L, -3L, 2L, 7L, 8L), logi_w, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hou %in% c(4L, -3L, 2L, 7L, 8L), logi_y, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hou %in% c(4L, -3L, 2L, 7L, 8L), logi_y, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hov %in% c(4L, -3L, 2L, 7L, 8L), logi_k, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hov %in% c(4L, -3L, 2L, 7L, 8L), logi_k, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(how %in% 1:4, , ),
bor3(how %in% 1:4, , ))
expect_equal(or3s(hox %in% 1:4, , ),
bor3(hox %in% 1:4, , ))
expect_equal(or3s(hoy %in% 1:4, , ),
bor3(hoy %in% 1:4, , ))
expect_equal(or3s(hoz %in% 1:4, , h %in% 1:4),
bor3(hoz %in% 1:4, , h %in% 1:4))
expect_equal(or3s(hpa %in% 1:4, , k %in% 1:4),
bor3(hpa %in% 1:4, , k %in% 1:4))
expect_equal(or3s(hpb %in% 1:4, , i %in% 1:4),
bor3(hpb %in% 1:4, , i %in% 1:4))
expect_equal(or3s(hpc %in% 1:4, logi_w, ),
bor3(hpc %in% 1:4, logi_w, ))
expect_equal(or3s(hpd %in% 1:4, logi_q, ),
bor3(hpd %in% 1:4, logi_q, ))
expect_equal(or3s(hpe %in% 1:4, logi_c, ),
bor3(hpe %in% 1:4, logi_c, ))
expect_equal(or3s(hpf %in% 1:4, logi_d, e %in% 1:4),
bor3(hpf %in% 1:4, logi_d, e %in% 1:4))
expect_equal(or3s(hpg %in% 1:4, logi_j, y %in% 1:4),
bor3(hpg %in% 1:4, logi_j, y %in% 1:4))
expect_equal(or3s(hph %in% 1:4, logi_j, u %in% 1:4),
bor3(hph %in% 1:4, logi_j, u %in% 1:4))
expect_equal(or3s(hpi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hpi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hpj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hpj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hpk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hpk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hpl %in% c(4L, -3L, 2L, 7L, 8L), , d < 0L),
bor3(hpl %in% c(4L, -3L, 2L, 7L, 8L), , d < 0L))
expect_equal(or3s(hpm %in% c(4L, -3L, 2L, 7L, 8L), , n < 1L),
bor3(hpm %in% c(4L, -3L, 2L, 7L, 8L), , n < 1L))
expect_equal(or3s(hpn %in% c(4L, -3L, 2L, 7L, 8L), , g < 9L),
bor3(hpn %in% c(4L, -3L, 2L, 7L, 8L), , g < 9L))
expect_equal(or3s(hpo %in% c(4L, -3L, 2L, 7L, 8L), logi_t, ),
bor3(hpo %in% c(4L, -3L, 2L, 7L, 8L), logi_t, ))
expect_equal(or3s(hpp %in% c(4L, -3L, 2L, 7L, 8L), logi_t, ),
bor3(hpp %in% c(4L, -3L, 2L, 7L, 8L), logi_t, ))
expect_equal(or3s(hpq %in% c(4L, -3L, 2L, 7L, 8L), logi_r, ),
bor3(hpq %in% c(4L, -3L, 2L, 7L, 8L), logi_r, ))
expect_equal(or3s(hpr %in% c(4L, -3L, 2L, 7L, 8L), logi_k, b < 0L),
bor3(hpr %in% c(4L, -3L, 2L, 7L, 8L), logi_k, b < 0L))
expect_equal(or3s(hps %in% c(4L, -3L, 2L, 7L, 8L), logi_d, h < 1L),
bor3(hps %in% c(4L, -3L, 2L, 7L, 8L), logi_d, h < 1L))
expect_equal(or3s(hpt %in% c(4L, -3L, 2L, 7L, 8L), logi_v, i < 9L),
bor3(hpt %in% c(4L, -3L, 2L, 7L, 8L), logi_v, i < 9L))
expect_equal(or3s(hpu %in% 1:4, , ),
bor3(hpu %in% 1:4, , ))
expect_equal(or3s(hpv %in% 1:4, , ),
bor3(hpv %in% 1:4, , ))
expect_equal(or3s(hpw %in% 1:4, , ),
bor3(hpw %in% 1:4, , ))
expect_equal(or3s(hpx %in% 1:4, , f < 0L),
bor3(hpx %in% 1:4, , f < 0L))
expect_equal(or3s(hpy %in% 1:4, , n < 1L),
bor3(hpy %in% 1:4, , n < 1L))
expect_equal(or3s(hpz %in% 1:4, , d < 9L),
bor3(hpz %in% 1:4, , d < 9L))
expect_equal(or3s(hqa %in% 1:4, logi_d, ),
bor3(hqa %in% 1:4, logi_d, ))
expect_equal(or3s(hqb %in% 1:4, logi_z, ),
bor3(hqb %in% 1:4, logi_z, ))
expect_equal(or3s(hqc %in% 1:4, logi_q, ),
bor3(hqc %in% 1:4, logi_q, ))
expect_equal(or3s(hqd %in% 1:4, logi_e, b < 0L),
bor3(hqd %in% 1:4, logi_e, b < 0L))
expect_equal(or3s(hqe %in% 1:4, logi_t, y < 1L),
bor3(hqe %in% 1:4, logi_t, y < 1L))
expect_equal(or3s(hqf %in% 1:4, logi_x, l < 9L),
bor3(hqf %in% 1:4, logi_x, l < 9L))
expect_equal(or3s(hqg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hqg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hqh %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hqh %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hqi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hqi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hqj %in% c(4L, -3L, 2L, 7L, 8L), , s <= 0L),
bor3(hqj %in% c(4L, -3L, 2L, 7L, 8L), , s <= 0L))
expect_equal(or3s(hqk %in% c(4L, -3L, 2L, 7L, 8L), , i <= 1L),
bor3(hqk %in% c(4L, -3L, 2L, 7L, 8L), , i <= 1L))
expect_equal(or3s(hql %in% c(4L, -3L, 2L, 7L, 8L), , l <= 9L),
bor3(hql %in% c(4L, -3L, 2L, 7L, 8L), , l <= 9L))
expect_equal(or3s(hqm %in% c(4L, -3L, 2L, 7L, 8L), logi_i, ),
bor3(hqm %in% c(4L, -3L, 2L, 7L, 8L), logi_i, ))
expect_equal(or3s(hqn %in% c(4L, -3L, 2L, 7L, 8L), logi_y, ),
bor3(hqn %in% c(4L, -3L, 2L, 7L, 8L), logi_y, ))
expect_equal(or3s(hqo %in% c(4L, -3L, 2L, 7L, 8L), logi_p, ),
bor3(hqo %in% c(4L, -3L, 2L, 7L, 8L), logi_p, ))
expect_equal(or3s(hqp %in% c(4L, -3L, 2L, 7L, 8L), logi_q, x <= 0L),
bor3(hqp %in% c(4L, -3L, 2L, 7L, 8L), logi_q, x <= 0L))
expect_equal(or3s(hqq %in% c(4L, -3L, 2L, 7L, 8L), logi_v, f <= 1L),
bor3(hqq %in% c(4L, -3L, 2L, 7L, 8L), logi_v, f <= 1L))
expect_equal(or3s(hqr %in% c(4L, -3L, 2L, 7L, 8L), logi_l, l <= 9L),
bor3(hqr %in% c(4L, -3L, 2L, 7L, 8L), logi_l, l <= 9L))
expect_equal(or3s(hqs %in% 1:4, , ),
bor3(hqs %in% 1:4, , ))
expect_equal(or3s(hqt %in% 1:4, , ),
bor3(hqt %in% 1:4, , ))
expect_equal(or3s(hqu %in% 1:4, , ),
bor3(hqu %in% 1:4, , ))
expect_equal(or3s(hqv %in% 1:4, , j <= 0L),
bor3(hqv %in% 1:4, , j <= 0L))
expect_equal(or3s(hqw %in% 1:4, , g <= 1L),
bor3(hqw %in% 1:4, , g <= 1L))
expect_equal(or3s(hqx %in% 1:4, , x <= 9L),
bor3(hqx %in% 1:4, , x <= 9L))
expect_equal(or3s(hqy %in% 1:4, logi_q, ),
bor3(hqy %in% 1:4, logi_q, ))
expect_equal(or3s(hqz %in% 1:4, logi_m, ),
bor3(hqz %in% 1:4, logi_m, ))
expect_equal(or3s(hra %in% 1:4, logi_z, ),
bor3(hra %in% 1:4, logi_z, ))
expect_equal(or3s(hrb %in% 1:4, logi_l, k <= 0L),
bor3(hrb %in% 1:4, logi_l, k <= 0L))
expect_equal(or3s(hrc %in% 1:4, logi_a, d <= 1L),
bor3(hrc %in% 1:4, logi_a, d <= 1L))
expect_equal(or3s(hrd %in% 1:4, logi_s, o <= 9L),
bor3(hrd %in% 1:4, logi_s, o <= 9L))
expect_equal(or3s(hre %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hre %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hrf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hrf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hrg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hrg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hrh %in% c(4L, -3L, 2L, 7L, 8L), , v == 0L),
bor3(hrh %in% c(4L, -3L, 2L, 7L, 8L), , v == 0L))
expect_equal(or3s(hri %in% c(4L, -3L, 2L, 7L, 8L), , u == 1L),
bor3(hri %in% c(4L, -3L, 2L, 7L, 8L), , u == 1L))
expect_equal(or3s(hrj %in% c(4L, -3L, 2L, 7L, 8L), , y == 9L),
bor3(hrj %in% c(4L, -3L, 2L, 7L, 8L), , y == 9L))
expect_equal(or3s(hrk %in% c(4L, -3L, 2L, 7L, 8L), logi_i, ),
bor3(hrk %in% c(4L, -3L, 2L, 7L, 8L), logi_i, ))
expect_equal(or3s(hrl %in% c(4L, -3L, 2L, 7L, 8L), logi_v, ),
bor3(hrl %in% c(4L, -3L, 2L, 7L, 8L), logi_v, ))
expect_equal(or3s(hrm %in% c(4L, -3L, 2L, 7L, 8L), logi_e, ),
bor3(hrm %in% c(4L, -3L, 2L, 7L, 8L), logi_e, ))
expect_equal(or3s(hrn %in% c(4L, -3L, 2L, 7L, 8L), logi_p, i == 0L),
bor3(hrn %in% c(4L, -3L, 2L, 7L, 8L), logi_p, i == 0L))
expect_equal(or3s(hro %in% c(4L, -3L, 2L, 7L, 8L), logi_u, y == 1L),
bor3(hro %in% c(4L, -3L, 2L, 7L, 8L), logi_u, y == 1L))
expect_equal(or3s(hrp %in% c(4L, -3L, 2L, 7L, 8L), logi_n, t == 9L),
bor3(hrp %in% c(4L, -3L, 2L, 7L, 8L), logi_n, t == 9L))
expect_equal(or3s(hrq %in% 1:4, , ),
bor3(hrq %in% 1:4, , ))
expect_equal(or3s(hrr %in% 1:4, , ),
bor3(hrr %in% 1:4, , ))
expect_equal(or3s(hrs %in% 1:4, , ),
bor3(hrs %in% 1:4, , ))
expect_equal(or3s(hrt %in% 1:4, , q == 0L),
bor3(hrt %in% 1:4, , q == 0L))
expect_equal(or3s(hru %in% 1:4, , c == 1L),
bor3(hru %in% 1:4, , c == 1L))
expect_equal(or3s(hrv %in% 1:4, , a == 9L),
bor3(hrv %in% 1:4, , a == 9L))
expect_equal(or3s(hrw %in% 1:4, logi_b, ),
bor3(hrw %in% 1:4, logi_b, ))
expect_equal(or3s(hrx %in% 1:4, logi_o, ),
bor3(hrx %in% 1:4, logi_o, ))
expect_equal(or3s(hry %in% 1:4, logi_o, ),
bor3(hry %in% 1:4, logi_o, ))
expect_equal(or3s(hrz %in% 1:4, logi_i, w == 0L),
bor3(hrz %in% 1:4, logi_i, w == 0L))
expect_equal(or3s(hsa %in% 1:4, logi_r, p == 1L),
bor3(hsa %in% 1:4, logi_r, p == 1L))
expect_equal(or3s(hsb %in% 1:4, logi_d, p == 9L),
bor3(hsb %in% 1:4, logi_d, p == 9L))
expect_equal(or3s(hsc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hsc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hsd %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hsd %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hse %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hse %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hsf %in% c(4L, -3L, 2L, 7L, 8L), , e > 0L),
bor3(hsf %in% c(4L, -3L, 2L, 7L, 8L), , e > 0L))
expect_equal(or3s(hsg %in% c(4L, -3L, 2L, 7L, 8L), , e > 1L),
bor3(hsg %in% c(4L, -3L, 2L, 7L, 8L), , e > 1L))
expect_equal(or3s(hsh %in% c(4L, -3L, 2L, 7L, 8L), , w > 9L),
bor3(hsh %in% c(4L, -3L, 2L, 7L, 8L), , w > 9L))
expect_equal(or3s(hsi %in% c(4L, -3L, 2L, 7L, 8L), logi_b, ),
bor3(hsi %in% c(4L, -3L, 2L, 7L, 8L), logi_b, ))
expect_equal(or3s(hsj %in% c(4L, -3L, 2L, 7L, 8L), logi_r, ),
bor3(hsj %in% c(4L, -3L, 2L, 7L, 8L), logi_r, ))
expect_equal(or3s(hsk %in% c(4L, -3L, 2L, 7L, 8L), logi_b, ),
bor3(hsk %in% c(4L, -3L, 2L, 7L, 8L), logi_b, ))
expect_equal(or3s(hsl %in% c(4L, -3L, 2L, 7L, 8L), logi_p, j > 0L),
bor3(hsl %in% c(4L, -3L, 2L, 7L, 8L), logi_p, j > 0L))
expect_equal(or3s(hsm %in% c(4L, -3L, 2L, 7L, 8L), logi_u, r > 1L),
bor3(hsm %in% c(4L, -3L, 2L, 7L, 8L), logi_u, r > 1L))
expect_equal(or3s(hsn %in% c(4L, -3L, 2L, 7L, 8L), logi_e, p > 9L),
bor3(hsn %in% c(4L, -3L, 2L, 7L, 8L), logi_e, p > 9L))
expect_equal(or3s(hso %in% 1:4, , ),
bor3(hso %in% 1:4, , ))
expect_equal(or3s(hsp %in% 1:4, , ),
bor3(hsp %in% 1:4, , ))
expect_equal(or3s(hsq %in% 1:4, , ),
bor3(hsq %in% 1:4, , ))
expect_equal(or3s(hsr %in% 1:4, , d > 0L),
bor3(hsr %in% 1:4, , d > 0L))
expect_equal(or3s(hss %in% 1:4, , s > 1L),
bor3(hss %in% 1:4, , s > 1L))
expect_equal(or3s(hst %in% 1:4, , s > 9L),
bor3(hst %in% 1:4, , s > 9L))
expect_equal(or3s(hsu %in% 1:4, logi_w, ),
bor3(hsu %in% 1:4, logi_w, ))
expect_equal(or3s(hsv %in% 1:4, logi_r, ),
bor3(hsv %in% 1:4, logi_r, ))
expect_equal(or3s(hsw %in% 1:4, logi_j, ),
bor3(hsw %in% 1:4, logi_j, ))
expect_equal(or3s(hsx %in% 1:4, logi_z, d > 0L),
bor3(hsx %in% 1:4, logi_z, d > 0L))
expect_equal(or3s(hsy %in% 1:4, logi_l, o > 1L),
bor3(hsy %in% 1:4, logi_l, o > 1L))
expect_equal(or3s(hsz %in% 1:4, logi_m, k > 9L),
bor3(hsz %in% 1:4, logi_m, k > 9L))
expect_equal(or3s(hta %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hta %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(htb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(htb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(htc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(htc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(htd %in% c(4L, -3L, 2L, 7L, 8L), , t >= 0L),
bor3(htd %in% c(4L, -3L, 2L, 7L, 8L), , t >= 0L))
expect_equal(or3s(hte %in% c(4L, -3L, 2L, 7L, 8L), , p >= 1L),
bor3(hte %in% c(4L, -3L, 2L, 7L, 8L), , p >= 1L))
expect_equal(or3s(htf %in% c(4L, -3L, 2L, 7L, 8L), , r >= 9L),
bor3(htf %in% c(4L, -3L, 2L, 7L, 8L), , r >= 9L))
expect_equal(or3s(htg %in% c(4L, -3L, 2L, 7L, 8L), logi_m, ),
bor3(htg %in% c(4L, -3L, 2L, 7L, 8L), logi_m, ))
expect_equal(or3s(hth %in% c(4L, -3L, 2L, 7L, 8L), logi_q, ),
bor3(hth %in% c(4L, -3L, 2L, 7L, 8L), logi_q, ))
expect_equal(or3s(hti %in% c(4L, -3L, 2L, 7L, 8L), logi_c, ),
bor3(hti %in% c(4L, -3L, 2L, 7L, 8L), logi_c, ))
expect_equal(or3s(htj %in% c(4L, -3L, 2L, 7L, 8L), logi_a, b >= 0L),
bor3(htj %in% c(4L, -3L, 2L, 7L, 8L), logi_a, b >= 0L))
expect_equal(or3s(htk %in% c(4L, -3L, 2L, 7L, 8L), logi_c, i >= 1L),
bor3(htk %in% c(4L, -3L, 2L, 7L, 8L), logi_c, i >= 1L))
expect_equal(or3s(htl %in% c(4L, -3L, 2L, 7L, 8L), logi_s, h >= 9L),
bor3(htl %in% c(4L, -3L, 2L, 7L, 8L), logi_s, h >= 9L))
expect_equal(or3s(htm %in% 1:4, , ),
bor3(htm %in% 1:4, , ))
expect_equal(or3s(htn %in% 1:4, , ),
bor3(htn %in% 1:4, , ))
expect_equal(or3s(hto %in% 1:4, , ),
bor3(hto %in% 1:4, , ))
expect_equal(or3s(htp %in% 1:4, , e >= 0L),
bor3(htp %in% 1:4, , e >= 0L))
expect_equal(or3s(htq %in% 1:4, , s >= 1L),
bor3(htq %in% 1:4, , s >= 1L))
expect_equal(or3s(htr %in% 1:4, , l >= 9L),
bor3(htr %in% 1:4, , l >= 9L))
expect_equal(or3s(hts %in% 1:4, logi_n, ),
bor3(hts %in% 1:4, logi_n, ))
expect_equal(or3s(htt %in% 1:4, logi_p, ),
bor3(htt %in% 1:4, logi_p, ))
expect_equal(or3s(htu %in% 1:4, logi_e, ),
bor3(htu %in% 1:4, logi_e, ))
expect_equal(or3s(htv %in% 1:4, logi_l, x >= 0L),
bor3(htv %in% 1:4, logi_l, x >= 0L))
expect_equal(or3s(htw %in% 1:4, logi_t, d >= 1L),
bor3(htw %in% 1:4, logi_t, d >= 1L))
expect_equal(or3s(htx %in% 1:4, logi_i, m >= 9L),
bor3(htx %in% 1:4, logi_i, m >= 9L))
expect_equal(or3s(hty %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hty %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(htz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(htz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hua %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hua %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hub %in% c(4L, -3L, 2L, 7L, 8L), , logi_c),
bor3(hub %in% c(4L, -3L, 2L, 7L, 8L), , logi_c))
expect_equal(or3s(huc %in% c(4L, -3L, 2L, 7L, 8L), , logi_j),
bor3(huc %in% c(4L, -3L, 2L, 7L, 8L), , logi_j))
expect_equal(or3s(hud %in% c(4L, -3L, 2L, 7L, 8L), , logi_x),
bor3(hud %in% c(4L, -3L, 2L, 7L, 8L), , logi_x))
expect_equal(or3s(hue %in% c(4L, -3L, 2L, 7L, 8L), !logi_g, ),
bor3(hue %in% c(4L, -3L, 2L, 7L, 8L), !logi_g, ))
expect_equal(or3s(huf %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, ),
bor3(huf %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, ))
expect_equal(or3s(hug %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, ),
bor3(hug %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, ))
expect_equal(or3s(huh %in% c(4L, -3L, 2L, 7L, 8L), !logi_y, logi_h),
bor3(huh %in% c(4L, -3L, 2L, 7L, 8L), !logi_y, logi_h))
expect_equal(or3s(hui %in% c(4L, -3L, 2L, 7L, 8L), !logi_f, logi_g),
bor3(hui %in% c(4L, -3L, 2L, 7L, 8L), !logi_f, logi_g))
expect_equal(or3s(huj %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, logi_i),
bor3(huj %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, logi_i))
expect_equal(or3s(huk %in% 1:4, , ),
bor3(huk %in% 1:4, , ))
expect_equal(or3s(hul %in% 1:4, , ),
bor3(hul %in% 1:4, , ))
expect_equal(or3s(hum %in% 1:4, , ),
bor3(hum %in% 1:4, , ))
expect_equal(or3s(hun %in% 1:4, , logi_d),
bor3(hun %in% 1:4, , logi_d))
expect_equal(or3s(huo %in% 1:4, , logi_w),
bor3(huo %in% 1:4, , logi_w))
expect_equal(or3s(hup %in% 1:4, , logi_f),
bor3(hup %in% 1:4, , logi_f))
expect_equal(or3s(huq %in% 1:4, !logi_h, ),
bor3(huq %in% 1:4, !logi_h, ))
expect_equal(or3s(hur %in% 1:4, !logi_q, ),
bor3(hur %in% 1:4, !logi_q, ))
expect_equal(or3s(hus %in% 1:4, !logi_e, ),
bor3(hus %in% 1:4, !logi_e, ))
expect_equal(or3s(hut %in% 1:4, !logi_s, logi_g),
bor3(hut %in% 1:4, !logi_s, logi_g))
expect_equal(or3s(huu %in% 1:4, !logi_h, logi_k),
bor3(huu %in% 1:4, !logi_h, logi_k))
expect_equal(or3s(huv %in% 1:4, !logi_q, logi_n),
bor3(huv %in% 1:4, !logi_q, logi_n))
expect_equal(or3s(huw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(huw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hux %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hux %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(huy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(huy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(huz %in% c(4L, -3L, 2L, 7L, 8L), , !logi_u),
bor3(huz %in% c(4L, -3L, 2L, 7L, 8L), , !logi_u))
expect_equal(or3s(hva %in% c(4L, -3L, 2L, 7L, 8L), , !logi_f),
bor3(hva %in% c(4L, -3L, 2L, 7L, 8L), , !logi_f))
expect_equal(or3s(hvb %in% c(4L, -3L, 2L, 7L, 8L), , !logi_f),
bor3(hvb %in% c(4L, -3L, 2L, 7L, 8L), , !logi_f))
expect_equal(or3s(hvc %in% c(4L, -3L, 2L, 7L, 8L), !logi_k, ),
bor3(hvc %in% c(4L, -3L, 2L, 7L, 8L), !logi_k, ))
expect_equal(or3s(hvd %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, ),
bor3(hvd %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, ))
expect_equal(or3s(hve %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, ),
bor3(hve %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, ))
expect_equal(or3s(hvf %in% c(4L, -3L, 2L, 7L, 8L), !logi_b, !logi_z),
bor3(hvf %in% c(4L, -3L, 2L, 7L, 8L), !logi_b, !logi_z))
expect_equal(or3s(hvg %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, !logi_o),
bor3(hvg %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, !logi_o))
expect_equal(or3s(hvh %in% c(4L, -3L, 2L, 7L, 8L), !logi_v, !logi_p),
bor3(hvh %in% c(4L, -3L, 2L, 7L, 8L), !logi_v, !logi_p))
expect_equal(or3s(hvi %in% 1:4, , ),
bor3(hvi %in% 1:4, , ))
expect_equal(or3s(hvj %in% 1:4, , ),
bor3(hvj %in% 1:4, , ))
expect_equal(or3s(hvk %in% 1:4, , ),
bor3(hvk %in% 1:4, , ))
expect_equal(or3s(hvl %in% 1:4, , !logi_g),
bor3(hvl %in% 1:4, , !logi_g))
expect_equal(or3s(hvm %in% 1:4, , !logi_d),
bor3(hvm %in% 1:4, , !logi_d))
expect_equal(or3s(hvn %in% 1:4, , !logi_d),
bor3(hvn %in% 1:4, , !logi_d))
expect_equal(or3s(hvo %in% 1:4, !logi_g, ),
bor3(hvo %in% 1:4, !logi_g, ))
expect_equal(or3s(hvp %in% 1:4, !logi_q, ),
bor3(hvp %in% 1:4, !logi_q, ))
expect_equal(or3s(hvq %in% 1:4, !logi_i, ),
bor3(hvq %in% 1:4, !logi_i, ))
expect_equal(or3s(hvr %in% 1:4, !logi_w, !logi_n),
bor3(hvr %in% 1:4, !logi_w, !logi_n))
expect_equal(or3s(hvs %in% 1:4, !logi_z, !logi_f),
bor3(hvs %in% 1:4, !logi_z, !logi_f))
expect_equal(or3s(hvt %in% 1:4, !logi_a, !logi_y),
bor3(hvt %in% 1:4, !logi_a, !logi_y))
expect_equal(or3s(hvu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hvu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hvv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hvv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hvw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hvw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hvx %in% c(4L, -3L, 2L, 7L, 8L), , f != 0L),
bor3(hvx %in% c(4L, -3L, 2L, 7L, 8L), , f != 0L))
expect_equal(or3s(hvy %in% c(4L, -3L, 2L, 7L, 8L), , t != 1L),
bor3(hvy %in% c(4L, -3L, 2L, 7L, 8L), , t != 1L))
expect_equal(or3s(hvz %in% c(4L, -3L, 2L, 7L, 8L), , z != 9L),
bor3(hvz %in% c(4L, -3L, 2L, 7L, 8L), , z != 9L))
expect_equal(or3s(hwa %in% c(4L, -3L, 2L, 7L, 8L), !logi_u, ),
bor3(hwa %in% c(4L, -3L, 2L, 7L, 8L), !logi_u, ))
expect_equal(or3s(hwb %in% c(4L, -3L, 2L, 7L, 8L), !logi_j, ),
bor3(hwb %in% c(4L, -3L, 2L, 7L, 8L), !logi_j, ))
expect_equal(or3s(hwc %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, ),
bor3(hwc %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, ))
expect_equal(or3s(hwd %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, u != 0L),
bor3(hwd %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, u != 0L))
expect_equal(or3s(hwe %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, c != 1L),
bor3(hwe %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, c != 1L))
expect_equal(or3s(hwf %in% c(4L, -3L, 2L, 7L, 8L), !logi_j, h != 9L),
bor3(hwf %in% c(4L, -3L, 2L, 7L, 8L), !logi_j, h != 9L))
expect_equal(or3s(hwg %in% 1:4, , ),
bor3(hwg %in% 1:4, , ))
expect_equal(or3s(hwh %in% 1:4, , ),
bor3(hwh %in% 1:4, , ))
expect_equal(or3s(hwi %in% 1:4, , ),
bor3(hwi %in% 1:4, , ))
expect_equal(or3s(hwj %in% 1:4, , r != 0L),
bor3(hwj %in% 1:4, , r != 0L))
expect_equal(or3s(hwk %in% 1:4, , v != 1L),
bor3(hwk %in% 1:4, , v != 1L))
expect_equal(or3s(hwl %in% 1:4, , n != 9L),
bor3(hwl %in% 1:4, , n != 9L))
expect_equal(or3s(hwm %in% 1:4, !logi_k, ),
bor3(hwm %in% 1:4, !logi_k, ))
expect_equal(or3s(hwn %in% 1:4, !logi_a, ),
bor3(hwn %in% 1:4, !logi_a, ))
expect_equal(or3s(hwo %in% 1:4, !logi_v, ),
bor3(hwo %in% 1:4, !logi_v, ))
expect_equal(or3s(hwp %in% 1:4, !logi_u, r != 0L),
bor3(hwp %in% 1:4, !logi_u, r != 0L))
expect_equal(or3s(hwq %in% 1:4, !logi_w, k != 1L),
bor3(hwq %in% 1:4, !logi_w, k != 1L))
expect_equal(or3s(hwr %in% 1:4, !logi_b, a != 9L),
bor3(hwr %in% 1:4, !logi_b, a != 9L))
expect_equal(or3s(hws %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hws %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hwt %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hwt %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hwu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hwu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hwv %in% c(4L, -3L, 2L, 7L, 8L), , u %between% c(-1L, 1L)),
bor3(hwv %in% c(4L, -3L, 2L, 7L, 8L), , u %between% c(-1L, 1L)))
expect_equal(or3s(hww %in% c(4L, -3L, 2L, 7L, 8L), , q %between% c(-1L, 1L)),
bor3(hww %in% c(4L, -3L, 2L, 7L, 8L), , q %between% c(-1L, 1L)))
expect_equal(or3s(hwx %in% c(4L, -3L, 2L, 7L, 8L), , z %between% c(-1L, 1L)),
bor3(hwx %in% c(4L, -3L, 2L, 7L, 8L), , z %between% c(-1L, 1L)))
expect_equal(or3s(hwy %in% c(4L, -3L, 2L, 7L, 8L), !logi_j, ),
bor3(hwy %in% c(4L, -3L, 2L, 7L, 8L), !logi_j, ))
expect_equal(or3s(hwz %in% c(4L, -3L, 2L, 7L, 8L), !logi_d, ),
bor3(hwz %in% c(4L, -3L, 2L, 7L, 8L), !logi_d, ))
expect_equal(or3s(hxa %in% c(4L, -3L, 2L, 7L, 8L), !logi_n, ),
bor3(hxa %in% c(4L, -3L, 2L, 7L, 8L), !logi_n, ))
expect_equal(or3s(hxb %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, b %between% c(-1L, 1L)),
bor3(hxb %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, b %between% c(-1L, 1L)))
expect_equal(or3s(hxc %in% c(4L, -3L, 2L, 7L, 8L), !logi_c, f %between% c(-1L, 1L)),
bor3(hxc %in% c(4L, -3L, 2L, 7L, 8L), !logi_c, f %between% c(-1L, 1L)))
expect_equal(or3s(hxd %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, a %between% c(-1L, 1L)),
bor3(hxd %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, a %between% c(-1L, 1L)))
expect_equal(or3s(hxe %in% 1:4, , ),
bor3(hxe %in% 1:4, , ))
expect_equal(or3s(hxf %in% 1:4, , ),
bor3(hxf %in% 1:4, , ))
expect_equal(or3s(hxg %in% 1:4, , ),
bor3(hxg %in% 1:4, , ))
expect_equal(or3s(hxh %in% 1:4, , e %between% c(-1L, 1L)),
bor3(hxh %in% 1:4, , e %between% c(-1L, 1L)))
expect_equal(or3s(hxi %in% 1:4, , n %between% c(-1L, 1L)),
bor3(hxi %in% 1:4, , n %between% c(-1L, 1L)))
expect_equal(or3s(hxj %in% 1:4, , y %between% c(-1L, 1L)),
bor3(hxj %in% 1:4, , y %between% c(-1L, 1L)))
expect_equal(or3s(hxk %in% 1:4, !logi_u, ),
bor3(hxk %in% 1:4, !logi_u, ))
expect_equal(or3s(hxl %in% 1:4, !logi_z, ),
bor3(hxl %in% 1:4, !logi_z, ))
expect_equal(or3s(hxm %in% 1:4, !logi_q, ),
bor3(hxm %in% 1:4, !logi_q, ))
expect_equal(or3s(hxn %in% 1:4, !logi_o, f %between% c(-1L, 1L)),
bor3(hxn %in% 1:4, !logi_o, f %between% c(-1L, 1L)))
expect_equal(or3s(hxo %in% 1:4, !logi_a, v %between% c(-1L, 1L)),
bor3(hxo %in% 1:4, !logi_a, v %between% c(-1L, 1L)))
expect_equal(or3s(hxp %in% 1:4, !logi_h, i %between% c(-1L, 1L)),
bor3(hxp %in% 1:4, !logi_h, i %between% c(-1L, 1L)))
expect_equal(or3s(hxq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hxq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hxr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hxr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hxs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hxs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hxt %in% c(4L, -3L, 2L, 7L, 8L), , q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hxt %in% c(4L, -3L, 2L, 7L, 8L), , q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hxu %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hxu %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hxv %in% c(4L, -3L, 2L, 7L, 8L), , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hxv %in% c(4L, -3L, 2L, 7L, 8L), , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hxw %in% c(4L, -3L, 2L, 7L, 8L), !logi_b, ),
bor3(hxw %in% c(4L, -3L, 2L, 7L, 8L), !logi_b, ))
expect_equal(or3s(hxx %in% c(4L, -3L, 2L, 7L, 8L), !logi_i, ),
bor3(hxx %in% c(4L, -3L, 2L, 7L, 8L), !logi_i, ))
expect_equal(or3s(hxy %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, ),
bor3(hxy %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, ))
expect_equal(or3s(hxz %in% c(4L, -3L, 2L, 7L, 8L), !logi_t, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hxz %in% c(4L, -3L, 2L, 7L, 8L), !logi_t, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hya %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hya %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hyb %in% c(4L, -3L, 2L, 7L, 8L), !logi_a, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(hyb %in% c(4L, -3L, 2L, 7L, 8L), !logi_a, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(hyc %in% 1:4, , ),
bor3(hyc %in% 1:4, , ))
expect_equal(or3s(hyd %in% 1:4, , ),
bor3(hyd %in% 1:4, , ))
expect_equal(or3s(hye %in% 1:4, , ),
bor3(hye %in% 1:4, , ))
expect_equal(or3s(hyf %in% 1:4, , t %in% 1:4),
bor3(hyf %in% 1:4, , t %in% 1:4))
expect_equal(or3s(hyg %in% 1:4, , q %in% 1:4),
bor3(hyg %in% 1:4, , q %in% 1:4))
expect_equal(or3s(hyh %in% 1:4, , l %in% 1:4),
bor3(hyh %in% 1:4, , l %in% 1:4))
expect_equal(or3s(hyi %in% 1:4, !logi_u, ),
bor3(hyi %in% 1:4, !logi_u, ))
expect_equal(or3s(hyj %in% 1:4, !logi_v, ),
bor3(hyj %in% 1:4, !logi_v, ))
expect_equal(or3s(hyk %in% 1:4, !logi_p, ),
bor3(hyk %in% 1:4, !logi_p, ))
expect_equal(or3s(hyl %in% 1:4, !logi_t, r %in% 1:4),
bor3(hyl %in% 1:4, !logi_t, r %in% 1:4))
expect_equal(or3s(hym %in% 1:4, !logi_v, d %in% 1:4),
bor3(hym %in% 1:4, !logi_v, d %in% 1:4))
expect_equal(or3s(hyn %in% 1:4, !logi_x, y %in% 1:4),
bor3(hyn %in% 1:4, !logi_x, y %in% 1:4))
expect_equal(or3s(hyo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hyo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hyp %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hyp %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hyq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(hyq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(hyr %in% c(4L, -3L, 2L, 7L, 8L), , u < 0L),
bor3(hyr %in% c(4L, -3L, 2L, 7L, 8L), , u < 0L))
expect_equal(or3s(hys %in% c(4L, -3L, 2L, 7L, 8L), , p < 1L),
bor3(hys %in% c(4L, -3L, 2L, 7L, 8L), , p < 1L))
expect_equal(or3s(hyt %in% c(4L, -3L, 2L, 7L, 8L), , s < 9L),
bor3(hyt %in% c(4L, -3L, 2L, 7L, 8L), , s < 9L))
expect_equal(or3s(hyu %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, ),
bor3(hyu %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, ))
expect_equal(or3s(hyv %in% c(4L, -3L, 2L, 7L, 8L), !logi_b, ),
bor3(hyv %in% c(4L, -3L, 2L, 7L, 8L), !logi_b, ))
expect_equal(or3s(hyw %in% c(4L, -3L, 2L, 7L, 8L), !logi_p, ),
bor3(hyw %in% c(4L, -3L, 2L, 7L, 8L), !logi_p, ))
expect_equal(or3s(hyx %in% c(4L, -3L, 2L, 7L, 8L), !logi_n, w < 0L),
bor3(hyx %in% c(4L, -3L, 2L, 7L, 8L), !logi_n, w < 0L))
expect_equal(or3s(hyy %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, u < 1L),
bor3(hyy %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, u < 1L))
expect_equal(or3s(hyz %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, s < 9L),
bor3(hyz %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, s < 9L))
expect_equal(or3s(ia %in% 1:4, , ),
bor3(ia %in% 1:4, , ))
expect_equal(or3s(ib %in% 1:4, , ),
bor3(ib %in% 1:4, , ))
expect_equal(or3s(ic %in% 1:4, , ),
bor3(ic %in% 1:4, , ))
expect_equal(or3s(id %in% 1:4, , d < 0L),
bor3(id %in% 1:4, , d < 0L))
expect_equal(or3s(ie %in% 1:4, , k < 1L),
bor3(ie %in% 1:4, , k < 1L))
expect_equal(or3s(IF %in% 1:4, , t < 9L),
bor3(IF %in% 1:4, , t < 9L))
expect_equal(or3s(ig %in% 1:4, !logi_d, ),
bor3(ig %in% 1:4, !logi_d, ))
expect_equal(or3s(ih %in% 1:4, !logi_n, ),
bor3(ih %in% 1:4, !logi_n, ))
expect_equal(or3s(ii %in% 1:4, !logi_c, ),
bor3(ii %in% 1:4, !logi_c, ))
expect_equal(or3s(ij %in% 1:4, !logi_x, h < 0L),
bor3(ij %in% 1:4, !logi_x, h < 0L))
expect_equal(or3s(ik %in% 1:4, !logi_z, q < 1L),
bor3(ik %in% 1:4, !logi_z, q < 1L))
expect_equal(or3s(il %in% 1:4, !logi_v, j < 9L),
bor3(il %in% 1:4, !logi_v, j < 9L))
expect_equal(or3s(im %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(im %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(IN %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(IN %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(io %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(io %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ip %in% c(4L, -3L, 2L, 7L, 8L), , c <= 0L),
bor3(ip %in% c(4L, -3L, 2L, 7L, 8L), , c <= 0L))
expect_equal(or3s(iq %in% c(4L, -3L, 2L, 7L, 8L), , w <= 1L),
bor3(iq %in% c(4L, -3L, 2L, 7L, 8L), , w <= 1L))
expect_equal(or3s(ir %in% c(4L, -3L, 2L, 7L, 8L), , c <= 9L),
bor3(ir %in% c(4L, -3L, 2L, 7L, 8L), , c <= 9L))
expect_equal(or3s(is %in% c(4L, -3L, 2L, 7L, 8L), !logi_s, ),
bor3(is %in% c(4L, -3L, 2L, 7L, 8L), !logi_s, ))
expect_equal(or3s(it %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, ),
bor3(it %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, ))
expect_equal(or3s(iu %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, ),
bor3(iu %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, ))
expect_equal(or3s(iv %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, o <= 0L),
bor3(iv %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, o <= 0L))
expect_equal(or3s(iw %in% c(4L, -3L, 2L, 7L, 8L), !logi_f, q <= 1L),
bor3(iw %in% c(4L, -3L, 2L, 7L, 8L), !logi_f, q <= 1L))
expect_equal(or3s(ix %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, m <= 9L),
bor3(ix %in% c(4L, -3L, 2L, 7L, 8L), !logi_q, m <= 9L))
expect_equal(or3s(iy %in% 1:4, , ),
bor3(iy %in% 1:4, , ))
expect_equal(or3s(iz %in% 1:4, , ),
bor3(iz %in% 1:4, , ))
expect_equal(or3s(iaa %in% 1:4, , ),
bor3(iaa %in% 1:4, , ))
expect_equal(or3s(iab %in% 1:4, , j <= 0L),
bor3(iab %in% 1:4, , j <= 0L))
expect_equal(or3s(iac %in% 1:4, , h <= 1L),
bor3(iac %in% 1:4, , h <= 1L))
expect_equal(or3s(iad %in% 1:4, , u <= 9L),
bor3(iad %in% 1:4, , u <= 9L))
expect_equal(or3s(iae %in% 1:4, !logi_k, ),
bor3(iae %in% 1:4, !logi_k, ))
expect_equal(or3s(iaf %in% 1:4, !logi_k, ),
bor3(iaf %in% 1:4, !logi_k, ))
expect_equal(or3s(iag %in% 1:4, !logi_p, ),
bor3(iag %in% 1:4, !logi_p, ))
expect_equal(or3s(iah %in% 1:4, !logi_t, g <= 0L),
bor3(iah %in% 1:4, !logi_t, g <= 0L))
expect_equal(or3s(iai %in% 1:4, !logi_r, r <= 1L),
bor3(iai %in% 1:4, !logi_r, r <= 1L))
expect_equal(or3s(iaj %in% 1:4, !logi_a, n <= 9L),
bor3(iaj %in% 1:4, !logi_a, n <= 9L))
expect_equal(or3s(iak %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iak %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ial %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ial %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iam %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iam %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ian %in% c(4L, -3L, 2L, 7L, 8L), , i == 0L),
bor3(ian %in% c(4L, -3L, 2L, 7L, 8L), , i == 0L))
expect_equal(or3s(iao %in% c(4L, -3L, 2L, 7L, 8L), , d == 1L),
bor3(iao %in% c(4L, -3L, 2L, 7L, 8L), , d == 1L))
expect_equal(or3s(iap %in% c(4L, -3L, 2L, 7L, 8L), , r == 9L),
bor3(iap %in% c(4L, -3L, 2L, 7L, 8L), , r == 9L))
expect_equal(or3s(iaq %in% c(4L, -3L, 2L, 7L, 8L), !logi_s, ),
bor3(iaq %in% c(4L, -3L, 2L, 7L, 8L), !logi_s, ))
expect_equal(or3s(iar %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, ),
bor3(iar %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, ))
expect_equal(or3s(ias %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, ),
bor3(ias %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, ))
expect_equal(or3s(iat %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, z == 0L),
bor3(iat %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, z == 0L))
expect_equal(or3s(iau %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, z == 1L),
bor3(iau %in% c(4L, -3L, 2L, 7L, 8L), !logi_h, z == 1L))
expect_equal(or3s(iav %in% c(4L, -3L, 2L, 7L, 8L), !logi_v, t == 9L),
bor3(iav %in% c(4L, -3L, 2L, 7L, 8L), !logi_v, t == 9L))
expect_equal(or3s(iaw %in% 1:4, , ),
bor3(iaw %in% 1:4, , ))
expect_equal(or3s(iax %in% 1:4, , ),
bor3(iax %in% 1:4, , ))
expect_equal(or3s(iay %in% 1:4, , ),
bor3(iay %in% 1:4, , ))
expect_equal(or3s(iaz %in% 1:4, , d == 0L),
bor3(iaz %in% 1:4, , d == 0L))
expect_equal(or3s(iba %in% 1:4, , n == 1L),
bor3(iba %in% 1:4, , n == 1L))
expect_equal(or3s(ibb %in% 1:4, , n == 9L),
bor3(ibb %in% 1:4, , n == 9L))
expect_equal(or3s(ibc %in% 1:4, !logi_r, ),
bor3(ibc %in% 1:4, !logi_r, ))
expect_equal(or3s(ibd %in% 1:4, !logi_a, ),
bor3(ibd %in% 1:4, !logi_a, ))
expect_equal(or3s(ibe %in% 1:4, !logi_w, ),
bor3(ibe %in% 1:4, !logi_w, ))
expect_equal(or3s(ibf %in% 1:4, !logi_r, x == 0L),
bor3(ibf %in% 1:4, !logi_r, x == 0L))
expect_equal(or3s(ibg %in% 1:4, !logi_y, i == 1L),
bor3(ibg %in% 1:4, !logi_y, i == 1L))
expect_equal(or3s(ibh %in% 1:4, !logi_w, r == 9L),
bor3(ibh %in% 1:4, !logi_w, r == 9L))
expect_equal(or3s(ibi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ibi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ibj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ibj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ibk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ibk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ibl %in% c(4L, -3L, 2L, 7L, 8L), , w > 0L),
bor3(ibl %in% c(4L, -3L, 2L, 7L, 8L), , w > 0L))
expect_equal(or3s(ibm %in% c(4L, -3L, 2L, 7L, 8L), , i > 1L),
bor3(ibm %in% c(4L, -3L, 2L, 7L, 8L), , i > 1L))
expect_equal(or3s(ibn %in% c(4L, -3L, 2L, 7L, 8L), , u > 9L),
bor3(ibn %in% c(4L, -3L, 2L, 7L, 8L), , u > 9L))
expect_equal(or3s(ibo %in% c(4L, -3L, 2L, 7L, 8L), !logi_d, ),
bor3(ibo %in% c(4L, -3L, 2L, 7L, 8L), !logi_d, ))
expect_equal(or3s(ibp %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, ),
bor3(ibp %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, ))
expect_equal(or3s(ibq %in% c(4L, -3L, 2L, 7L, 8L), !logi_t, ),
bor3(ibq %in% c(4L, -3L, 2L, 7L, 8L), !logi_t, ))
expect_equal(or3s(ibr %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, y > 0L),
bor3(ibr %in% c(4L, -3L, 2L, 7L, 8L), !logi_w, y > 0L))
expect_equal(or3s(ibs %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, d > 1L),
bor3(ibs %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, d > 1L))
expect_equal(or3s(ibt %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, o > 9L),
bor3(ibt %in% c(4L, -3L, 2L, 7L, 8L), !logi_r, o > 9L))
expect_equal(or3s(ibu %in% 1:4, , ),
bor3(ibu %in% 1:4, , ))
expect_equal(or3s(ibv %in% 1:4, , ),
bor3(ibv %in% 1:4, , ))
expect_equal(or3s(ibw %in% 1:4, , ),
bor3(ibw %in% 1:4, , ))
expect_equal(or3s(ibx %in% 1:4, , q > 0L),
bor3(ibx %in% 1:4, , q > 0L))
expect_equal(or3s(iby %in% 1:4, , h > 1L),
bor3(iby %in% 1:4, , h > 1L))
expect_equal(or3s(ibz %in% 1:4, , d > 9L),
bor3(ibz %in% 1:4, , d > 9L))
expect_equal(or3s(ica %in% 1:4, !logi_h, ),
bor3(ica %in% 1:4, !logi_h, ))
expect_equal(or3s(icb %in% 1:4, !logi_n, ),
bor3(icb %in% 1:4, !logi_n, ))
expect_equal(or3s(icc %in% 1:4, !logi_r, ),
bor3(icc %in% 1:4, !logi_r, ))
expect_equal(or3s(icd %in% 1:4, !logi_d, c > 0L),
bor3(icd %in% 1:4, !logi_d, c > 0L))
expect_equal(or3s(ice %in% 1:4, !logi_h, y > 1L),
bor3(ice %in% 1:4, !logi_h, y > 1L))
expect_equal(or3s(icf %in% 1:4, !logi_z, z > 9L),
bor3(icf %in% 1:4, !logi_z, z > 9L))
expect_equal(or3s(icg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(icg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ich %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ich %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ici %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ici %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(icj %in% c(4L, -3L, 2L, 7L, 8L), , f >= 0L),
bor3(icj %in% c(4L, -3L, 2L, 7L, 8L), , f >= 0L))
expect_equal(or3s(ick %in% c(4L, -3L, 2L, 7L, 8L), , f >= 1L),
bor3(ick %in% c(4L, -3L, 2L, 7L, 8L), , f >= 1L))
expect_equal(or3s(icl %in% c(4L, -3L, 2L, 7L, 8L), , t >= 9L),
bor3(icl %in% c(4L, -3L, 2L, 7L, 8L), , t >= 9L))
expect_equal(or3s(icm %in% c(4L, -3L, 2L, 7L, 8L), !logi_u, ),
bor3(icm %in% c(4L, -3L, 2L, 7L, 8L), !logi_u, ))
expect_equal(or3s(icn %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, ),
bor3(icn %in% c(4L, -3L, 2L, 7L, 8L), !logi_l, ))
expect_equal(or3s(ico %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, ),
bor3(ico %in% c(4L, -3L, 2L, 7L, 8L), !logi_m, ))
expect_equal(or3s(icp %in% c(4L, -3L, 2L, 7L, 8L), !logi_a, z >= 0L),
bor3(icp %in% c(4L, -3L, 2L, 7L, 8L), !logi_a, z >= 0L))
expect_equal(or3s(icq %in% c(4L, -3L, 2L, 7L, 8L), !logi_v, p >= 1L),
bor3(icq %in% c(4L, -3L, 2L, 7L, 8L), !logi_v, p >= 1L))
expect_equal(or3s(icr %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, t >= 9L),
bor3(icr %in% c(4L, -3L, 2L, 7L, 8L), !logi_z, t >= 9L))
expect_equal(or3s(ics %in% 1:4, , ),
bor3(ics %in% 1:4, , ))
expect_equal(or3s(ict %in% 1:4, , ),
bor3(ict %in% 1:4, , ))
expect_equal(or3s(icu %in% 1:4, , ),
bor3(icu %in% 1:4, , ))
expect_equal(or3s(icv %in% 1:4, , r >= 0L),
bor3(icv %in% 1:4, , r >= 0L))
expect_equal(or3s(icw %in% 1:4, , z >= 1L),
bor3(icw %in% 1:4, , z >= 1L))
expect_equal(or3s(icx %in% 1:4, , h >= 9L),
bor3(icx %in% 1:4, , h >= 9L))
expect_equal(or3s(icy %in% 1:4, !logi_a, ),
bor3(icy %in% 1:4, !logi_a, ))
expect_equal(or3s(icz %in% 1:4, !logi_r, ),
bor3(icz %in% 1:4, !logi_r, ))
expect_equal(or3s(ida %in% 1:4, !logi_l, ),
bor3(ida %in% 1:4, !logi_l, ))
expect_equal(or3s(idb %in% 1:4, !logi_n, d >= 0L),
bor3(idb %in% 1:4, !logi_n, d >= 0L))
expect_equal(or3s(idc %in% 1:4, !logi_z, j >= 1L),
bor3(idc %in% 1:4, !logi_z, j >= 1L))
expect_equal(or3s(idd %in% 1:4, !logi_q, z >= 9L),
bor3(idd %in% 1:4, !logi_q, z >= 9L))
expect_equal(or3s(ide %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ide %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(idf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(idf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(idg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(idg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(idh %in% c(4L, -3L, 2L, 7L, 8L), , logi_n),
bor3(idh %in% c(4L, -3L, 2L, 7L, 8L), , logi_n))
expect_equal(or3s(idi %in% c(4L, -3L, 2L, 7L, 8L), , logi_o),
bor3(idi %in% c(4L, -3L, 2L, 7L, 8L), , logi_o))
expect_equal(or3s(idj %in% c(4L, -3L, 2L, 7L, 8L), , logi_l),
bor3(idj %in% c(4L, -3L, 2L, 7L, 8L), , logi_l))
expect_equal(or3s(idk %in% c(4L, -3L, 2L, 7L, 8L), d != 0L, ),
bor3(idk %in% c(4L, -3L, 2L, 7L, 8L), d != 0L, ))
expect_equal(or3s(idl %in% c(4L, -3L, 2L, 7L, 8L), g != 1L, ),
bor3(idl %in% c(4L, -3L, 2L, 7L, 8L), g != 1L, ))
expect_equal(or3s(idm %in% c(4L, -3L, 2L, 7L, 8L), w != 9L, ),
bor3(idm %in% c(4L, -3L, 2L, 7L, 8L), w != 9L, ))
expect_equal(or3s(idn %in% c(4L, -3L, 2L, 7L, 8L), t != 0L, logi_v),
bor3(idn %in% c(4L, -3L, 2L, 7L, 8L), t != 0L, logi_v))
expect_equal(or3s(ido %in% c(4L, -3L, 2L, 7L, 8L), u != 1L, logi_j),
bor3(ido %in% c(4L, -3L, 2L, 7L, 8L), u != 1L, logi_j))
expect_equal(or3s(idp %in% c(4L, -3L, 2L, 7L, 8L), d != 9L, logi_u),
bor3(idp %in% c(4L, -3L, 2L, 7L, 8L), d != 9L, logi_u))
expect_equal(or3s(idq %in% 1:4, , ),
bor3(idq %in% 1:4, , ))
expect_equal(or3s(idr %in% 1:4, , ),
bor3(idr %in% 1:4, , ))
expect_equal(or3s(ids %in% 1:4, , ),
bor3(ids %in% 1:4, , ))
expect_equal(or3s(idt %in% 1:4, , logi_o),
bor3(idt %in% 1:4, , logi_o))
expect_equal(or3s(idu %in% 1:4, , logi_z),
bor3(idu %in% 1:4, , logi_z))
expect_equal(or3s(idv %in% 1:4, , logi_h),
bor3(idv %in% 1:4, , logi_h))
expect_equal(or3s(idw %in% 1:4, f != 0L, ),
bor3(idw %in% 1:4, f != 0L, ))
expect_equal(or3s(idx %in% 1:4, z != 1L, ),
bor3(idx %in% 1:4, z != 1L, ))
expect_equal(or3s(idy %in% 1:4, x != 9L, ),
bor3(idy %in% 1:4, x != 9L, ))
expect_equal(or3s(idz %in% 1:4, h != 0L, logi_e),
bor3(idz %in% 1:4, h != 0L, logi_e))
expect_equal(or3s(iea %in% 1:4, c != 1L, logi_q),
bor3(iea %in% 1:4, c != 1L, logi_q))
expect_equal(or3s(ieb %in% 1:4, j != 9L, logi_z),
bor3(ieb %in% 1:4, j != 9L, logi_z))
expect_equal(or3s(iec %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iec %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ied %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ied %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iee %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iee %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ief %in% c(4L, -3L, 2L, 7L, 8L), , !logi_q),
bor3(ief %in% c(4L, -3L, 2L, 7L, 8L), , !logi_q))
expect_equal(or3s(ieg %in% c(4L, -3L, 2L, 7L, 8L), , !logi_u),
bor3(ieg %in% c(4L, -3L, 2L, 7L, 8L), , !logi_u))
expect_equal(or3s(ieh %in% c(4L, -3L, 2L, 7L, 8L), , !logi_d),
bor3(ieh %in% c(4L, -3L, 2L, 7L, 8L), , !logi_d))
expect_equal(or3s(iei %in% c(4L, -3L, 2L, 7L, 8L), a != 0L, ),
bor3(iei %in% c(4L, -3L, 2L, 7L, 8L), a != 0L, ))
expect_equal(or3s(iej %in% c(4L, -3L, 2L, 7L, 8L), m != 1L, ),
bor3(iej %in% c(4L, -3L, 2L, 7L, 8L), m != 1L, ))
expect_equal(or3s(iek %in% c(4L, -3L, 2L, 7L, 8L), b != 9L, ),
bor3(iek %in% c(4L, -3L, 2L, 7L, 8L), b != 9L, ))
expect_equal(or3s(iel %in% c(4L, -3L, 2L, 7L, 8L), i != 0L, !logi_k),
bor3(iel %in% c(4L, -3L, 2L, 7L, 8L), i != 0L, !logi_k))
expect_equal(or3s(iem %in% c(4L, -3L, 2L, 7L, 8L), p != 1L, !logi_g),
bor3(iem %in% c(4L, -3L, 2L, 7L, 8L), p != 1L, !logi_g))
expect_equal(or3s(ien %in% c(4L, -3L, 2L, 7L, 8L), q != 9L, !logi_p),
bor3(ien %in% c(4L, -3L, 2L, 7L, 8L), q != 9L, !logi_p))
expect_equal(or3s(ieo %in% 1:4, , ),
bor3(ieo %in% 1:4, , ))
expect_equal(or3s(iep %in% 1:4, , ),
bor3(iep %in% 1:4, , ))
expect_equal(or3s(ieq %in% 1:4, , ),
bor3(ieq %in% 1:4, , ))
expect_equal(or3s(ier %in% 1:4, , !logi_x),
bor3(ier %in% 1:4, , !logi_x))
expect_equal(or3s(ies %in% 1:4, , !logi_p),
bor3(ies %in% 1:4, , !logi_p))
expect_equal(or3s(iet %in% 1:4, , !logi_l),
bor3(iet %in% 1:4, , !logi_l))
expect_equal(or3s(ieu %in% 1:4, m != 0L, ),
bor3(ieu %in% 1:4, m != 0L, ))
expect_equal(or3s(iev %in% 1:4, h != 1L, ),
bor3(iev %in% 1:4, h != 1L, ))
expect_equal(or3s(iew %in% 1:4, p != 9L, ),
bor3(iew %in% 1:4, p != 9L, ))
expect_equal(or3s(iex %in% 1:4, w != 0L, !logi_b),
bor3(iex %in% 1:4, w != 0L, !logi_b))
expect_equal(or3s(iey %in% 1:4, e != 1L, !logi_d),
bor3(iey %in% 1:4, e != 1L, !logi_d))
expect_equal(or3s(iez %in% 1:4, m != 9L, !logi_f),
bor3(iez %in% 1:4, m != 9L, !logi_f))
expect_equal(or3s(ifa %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ifa %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ifb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ifb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ifc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ifc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ifd %in% c(4L, -3L, 2L, 7L, 8L), , t != 0L),
bor3(ifd %in% c(4L, -3L, 2L, 7L, 8L), , t != 0L))
expect_equal(or3s(ife %in% c(4L, -3L, 2L, 7L, 8L), , v != 1L),
bor3(ife %in% c(4L, -3L, 2L, 7L, 8L), , v != 1L))
expect_equal(or3s(iff %in% c(4L, -3L, 2L, 7L, 8L), , o != 9L),
bor3(iff %in% c(4L, -3L, 2L, 7L, 8L), , o != 9L))
expect_equal(or3s(ifg %in% c(4L, -3L, 2L, 7L, 8L), e != 0L, ),
bor3(ifg %in% c(4L, -3L, 2L, 7L, 8L), e != 0L, ))
expect_equal(or3s(ifh %in% c(4L, -3L, 2L, 7L, 8L), o != 1L, ),
bor3(ifh %in% c(4L, -3L, 2L, 7L, 8L), o != 1L, ))
expect_equal(or3s(ifi %in% c(4L, -3L, 2L, 7L, 8L), i != 9L, ),
bor3(ifi %in% c(4L, -3L, 2L, 7L, 8L), i != 9L, ))
expect_equal(or3s(ifj %in% c(4L, -3L, 2L, 7L, 8L), e != 0L, y != 0L),
bor3(ifj %in% c(4L, -3L, 2L, 7L, 8L), e != 0L, y != 0L))
expect_equal(or3s(ifk %in% c(4L, -3L, 2L, 7L, 8L), b != 1L, m != 1L),
bor3(ifk %in% c(4L, -3L, 2L, 7L, 8L), b != 1L, m != 1L))
expect_equal(or3s(ifl %in% c(4L, -3L, 2L, 7L, 8L), u != 9L, s != 9L),
bor3(ifl %in% c(4L, -3L, 2L, 7L, 8L), u != 9L, s != 9L))
expect_equal(or3s(ifm %in% 1:4, , ),
bor3(ifm %in% 1:4, , ))
expect_equal(or3s(ifn %in% 1:4, , ),
bor3(ifn %in% 1:4, , ))
expect_equal(or3s(ifo %in% 1:4, , ),
bor3(ifo %in% 1:4, , ))
expect_equal(or3s(ifp %in% 1:4, , r != 0L),
bor3(ifp %in% 1:4, , r != 0L))
expect_equal(or3s(ifq %in% 1:4, , w != 1L),
bor3(ifq %in% 1:4, , w != 1L))
expect_equal(or3s(ifr %in% 1:4, , z != 9L),
bor3(ifr %in% 1:4, , z != 9L))
expect_equal(or3s(ifs %in% 1:4, i != 0L, ),
bor3(ifs %in% 1:4, i != 0L, ))
expect_equal(or3s(ift %in% 1:4, h != 1L, ),
bor3(ift %in% 1:4, h != 1L, ))
expect_equal(or3s(ifu %in% 1:4, w != 9L, ),
bor3(ifu %in% 1:4, w != 9L, ))
expect_equal(or3s(ifv %in% 1:4, p != 0L, m != 0L),
bor3(ifv %in% 1:4, p != 0L, m != 0L))
expect_equal(or3s(ifw %in% 1:4, w != 1L, l != 1L),
bor3(ifw %in% 1:4, w != 1L, l != 1L))
expect_equal(or3s(ifx %in% 1:4, r != 9L, r != 9L),
bor3(ifx %in% 1:4, r != 9L, r != 9L))
expect_equal(or3s(ify %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ify %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ifz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ifz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iga %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iga %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(igb %in% c(4L, -3L, 2L, 7L, 8L), , p %between% c(-1L, 1L)),
bor3(igb %in% c(4L, -3L, 2L, 7L, 8L), , p %between% c(-1L, 1L)))
expect_equal(or3s(igc %in% c(4L, -3L, 2L, 7L, 8L), , u %between% c(-1L, 1L)),
bor3(igc %in% c(4L, -3L, 2L, 7L, 8L), , u %between% c(-1L, 1L)))
expect_equal(or3s(igd %in% c(4L, -3L, 2L, 7L, 8L), , o %between% c(-1L, 1L)),
bor3(igd %in% c(4L, -3L, 2L, 7L, 8L), , o %between% c(-1L, 1L)))
expect_equal(or3s(ige %in% c(4L, -3L, 2L, 7L, 8L), z != 0L, ),
bor3(ige %in% c(4L, -3L, 2L, 7L, 8L), z != 0L, ))
expect_equal(or3s(igf %in% c(4L, -3L, 2L, 7L, 8L), o != 1L, ),
bor3(igf %in% c(4L, -3L, 2L, 7L, 8L), o != 1L, ))
expect_equal(or3s(igg %in% c(4L, -3L, 2L, 7L, 8L), b != 9L, ),
bor3(igg %in% c(4L, -3L, 2L, 7L, 8L), b != 9L, ))
expect_equal(or3s(igh %in% c(4L, -3L, 2L, 7L, 8L), v != 0L, t %between% c(-1L, 1L)),
bor3(igh %in% c(4L, -3L, 2L, 7L, 8L), v != 0L, t %between% c(-1L, 1L)))
expect_equal(or3s(igi %in% c(4L, -3L, 2L, 7L, 8L), m != 1L, e %between% c(-1L, 1L)),
bor3(igi %in% c(4L, -3L, 2L, 7L, 8L), m != 1L, e %between% c(-1L, 1L)))
expect_equal(or3s(igj %in% c(4L, -3L, 2L, 7L, 8L), n != 9L, g %between% c(-1L, 1L)),
bor3(igj %in% c(4L, -3L, 2L, 7L, 8L), n != 9L, g %between% c(-1L, 1L)))
expect_equal(or3s(igk %in% 1:4, , ),
bor3(igk %in% 1:4, , ))
expect_equal(or3s(igl %in% 1:4, , ),
bor3(igl %in% 1:4, , ))
expect_equal(or3s(igm %in% 1:4, , ),
bor3(igm %in% 1:4, , ))
expect_equal(or3s(ign %in% 1:4, , k %between% c(-1L, 1L)),
bor3(ign %in% 1:4, , k %between% c(-1L, 1L)))
expect_equal(or3s(igo %in% 1:4, , q %between% c(-1L, 1L)),
bor3(igo %in% 1:4, , q %between% c(-1L, 1L)))
expect_equal(or3s(igp %in% 1:4, , f %between% c(-1L, 1L)),
bor3(igp %in% 1:4, , f %between% c(-1L, 1L)))
expect_equal(or3s(igq %in% 1:4, w != 0L, ),
bor3(igq %in% 1:4, w != 0L, ))
expect_equal(or3s(igr %in% 1:4, w != 1L, ),
bor3(igr %in% 1:4, w != 1L, ))
expect_equal(or3s(igs %in% 1:4, z != 9L, ),
bor3(igs %in% 1:4, z != 9L, ))
expect_equal(or3s(igt %in% 1:4, c != 0L, e %between% c(-1L, 1L)),
bor3(igt %in% 1:4, c != 0L, e %between% c(-1L, 1L)))
expect_equal(or3s(igu %in% 1:4, d != 1L, x %between% c(-1L, 1L)),
bor3(igu %in% 1:4, d != 1L, x %between% c(-1L, 1L)))
expect_equal(or3s(igv %in% 1:4, o != 9L, n %between% c(-1L, 1L)),
bor3(igv %in% 1:4, o != 9L, n %between% c(-1L, 1L)))
expect_equal(or3s(igw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(igw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(igx %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(igx %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(igy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(igy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(igz %in% c(4L, -3L, 2L, 7L, 8L), , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(igz %in% c(4L, -3L, 2L, 7L, 8L), , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iha %in% c(4L, -3L, 2L, 7L, 8L), , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iha %in% c(4L, -3L, 2L, 7L, 8L), , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ihb %in% c(4L, -3L, 2L, 7L, 8L), , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ihb %in% c(4L, -3L, 2L, 7L, 8L), , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ihc %in% c(4L, -3L, 2L, 7L, 8L), k != 0L, ),
bor3(ihc %in% c(4L, -3L, 2L, 7L, 8L), k != 0L, ))
expect_equal(or3s(ihd %in% c(4L, -3L, 2L, 7L, 8L), o != 1L, ),
bor3(ihd %in% c(4L, -3L, 2L, 7L, 8L), o != 1L, ))
expect_equal(or3s(ihe %in% c(4L, -3L, 2L, 7L, 8L), u != 9L, ),
bor3(ihe %in% c(4L, -3L, 2L, 7L, 8L), u != 9L, ))
expect_equal(or3s(ihf %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ihf %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ihg %in% c(4L, -3L, 2L, 7L, 8L), r != 1L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ihg %in% c(4L, -3L, 2L, 7L, 8L), r != 1L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ihh %in% c(4L, -3L, 2L, 7L, 8L), y != 9L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ihh %in% c(4L, -3L, 2L, 7L, 8L), y != 9L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ihi %in% 1:4, , ),
bor3(ihi %in% 1:4, , ))
expect_equal(or3s(ihj %in% 1:4, , ),
bor3(ihj %in% 1:4, , ))
expect_equal(or3s(ihk %in% 1:4, , ),
bor3(ihk %in% 1:4, , ))
expect_equal(or3s(ihl %in% 1:4, , g %in% 1:4),
bor3(ihl %in% 1:4, , g %in% 1:4))
expect_equal(or3s(ihm %in% 1:4, , w %in% 1:4),
bor3(ihm %in% 1:4, , w %in% 1:4))
expect_equal(or3s(ihn %in% 1:4, , b %in% 1:4),
bor3(ihn %in% 1:4, , b %in% 1:4))
expect_equal(or3s(iho %in% 1:4, x != 0L, ),
bor3(iho %in% 1:4, x != 0L, ))
expect_equal(or3s(ihp %in% 1:4, t != 1L, ),
bor3(ihp %in% 1:4, t != 1L, ))
expect_equal(or3s(ihq %in% 1:4, i != 9L, ),
bor3(ihq %in% 1:4, i != 9L, ))
expect_equal(or3s(ihr %in% 1:4, p != 0L, v %in% 1:4),
bor3(ihr %in% 1:4, p != 0L, v %in% 1:4))
expect_equal(or3s(ihs %in% 1:4, p != 1L, l %in% 1:4),
bor3(ihs %in% 1:4, p != 1L, l %in% 1:4))
expect_equal(or3s(iht %in% 1:4, h != 9L, k %in% 1:4),
bor3(iht %in% 1:4, h != 9L, k %in% 1:4))
expect_equal(or3s(ihu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ihu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ihv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ihv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ihw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ihw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ihx %in% c(4L, -3L, 2L, 7L, 8L), , c < 0L),
bor3(ihx %in% c(4L, -3L, 2L, 7L, 8L), , c < 0L))
expect_equal(or3s(ihy %in% c(4L, -3L, 2L, 7L, 8L), , d < 1L),
bor3(ihy %in% c(4L, -3L, 2L, 7L, 8L), , d < 1L))
expect_equal(or3s(ihz %in% c(4L, -3L, 2L, 7L, 8L), , g < 9L),
bor3(ihz %in% c(4L, -3L, 2L, 7L, 8L), , g < 9L))
expect_equal(or3s(iia %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, ),
bor3(iia %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, ))
expect_equal(or3s(iib %in% c(4L, -3L, 2L, 7L, 8L), y != 1L, ),
bor3(iib %in% c(4L, -3L, 2L, 7L, 8L), y != 1L, ))
expect_equal(or3s(iic %in% c(4L, -3L, 2L, 7L, 8L), y != 9L, ),
bor3(iic %in% c(4L, -3L, 2L, 7L, 8L), y != 9L, ))
expect_equal(or3s(iid %in% c(4L, -3L, 2L, 7L, 8L), m != 0L, b < 0L),
bor3(iid %in% c(4L, -3L, 2L, 7L, 8L), m != 0L, b < 0L))
expect_equal(or3s(iie %in% c(4L, -3L, 2L, 7L, 8L), r != 1L, e < 1L),
bor3(iie %in% c(4L, -3L, 2L, 7L, 8L), r != 1L, e < 1L))
expect_equal(or3s(iif %in% c(4L, -3L, 2L, 7L, 8L), d != 9L, w < 9L),
bor3(iif %in% c(4L, -3L, 2L, 7L, 8L), d != 9L, w < 9L))
expect_equal(or3s(iig %in% 1:4, , ),
bor3(iig %in% 1:4, , ))
expect_equal(or3s(iih %in% 1:4, , ),
bor3(iih %in% 1:4, , ))
expect_equal(or3s(iii %in% 1:4, , ),
bor3(iii %in% 1:4, , ))
expect_equal(or3s(iij %in% 1:4, , m < 0L),
bor3(iij %in% 1:4, , m < 0L))
expect_equal(or3s(iik %in% 1:4, , p < 1L),
bor3(iik %in% 1:4, , p < 1L))
expect_equal(or3s(iil %in% 1:4, , p < 9L),
bor3(iil %in% 1:4, , p < 9L))
expect_equal(or3s(iim %in% 1:4, t != 0L, ),
bor3(iim %in% 1:4, t != 0L, ))
expect_equal(or3s(iin %in% 1:4, h != 1L, ),
bor3(iin %in% 1:4, h != 1L, ))
expect_equal(or3s(iio %in% 1:4, g != 9L, ),
bor3(iio %in% 1:4, g != 9L, ))
expect_equal(or3s(iip %in% 1:4, k != 0L, t < 0L),
bor3(iip %in% 1:4, k != 0L, t < 0L))
expect_equal(or3s(iiq %in% 1:4, u != 1L, r < 1L),
bor3(iiq %in% 1:4, u != 1L, r < 1L))
expect_equal(or3s(iir %in% 1:4, x != 9L, g < 9L),
bor3(iir %in% 1:4, x != 9L, g < 9L))
expect_equal(or3s(iis %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iis %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iit %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iit %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iiu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iiu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iiv %in% c(4L, -3L, 2L, 7L, 8L), , c <= 0L),
bor3(iiv %in% c(4L, -3L, 2L, 7L, 8L), , c <= 0L))
expect_equal(or3s(iiw %in% c(4L, -3L, 2L, 7L, 8L), , c <= 1L),
bor3(iiw %in% c(4L, -3L, 2L, 7L, 8L), , c <= 1L))
expect_equal(or3s(iix %in% c(4L, -3L, 2L, 7L, 8L), , v <= 9L),
bor3(iix %in% c(4L, -3L, 2L, 7L, 8L), , v <= 9L))
expect_equal(or3s(iiy %in% c(4L, -3L, 2L, 7L, 8L), y != 0L, ),
bor3(iiy %in% c(4L, -3L, 2L, 7L, 8L), y != 0L, ))
expect_equal(or3s(iiz %in% c(4L, -3L, 2L, 7L, 8L), a != 1L, ),
bor3(iiz %in% c(4L, -3L, 2L, 7L, 8L), a != 1L, ))
expect_equal(or3s(ija %in% c(4L, -3L, 2L, 7L, 8L), o != 9L, ),
bor3(ija %in% c(4L, -3L, 2L, 7L, 8L), o != 9L, ))
expect_equal(or3s(ijb %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, m <= 0L),
bor3(ijb %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, m <= 0L))
expect_equal(or3s(ijc %in% c(4L, -3L, 2L, 7L, 8L), h != 1L, h <= 1L),
bor3(ijc %in% c(4L, -3L, 2L, 7L, 8L), h != 1L, h <= 1L))
expect_equal(or3s(ijd %in% c(4L, -3L, 2L, 7L, 8L), s != 9L, g <= 9L),
bor3(ijd %in% c(4L, -3L, 2L, 7L, 8L), s != 9L, g <= 9L))
expect_equal(or3s(ije %in% 1:4, , ),
bor3(ije %in% 1:4, , ))
expect_equal(or3s(ijf %in% 1:4, , ),
bor3(ijf %in% 1:4, , ))
expect_equal(or3s(ijg %in% 1:4, , ),
bor3(ijg %in% 1:4, , ))
expect_equal(or3s(ijh %in% 1:4, , r <= 0L),
bor3(ijh %in% 1:4, , r <= 0L))
expect_equal(or3s(iji %in% 1:4, , s <= 1L),
bor3(iji %in% 1:4, , s <= 1L))
expect_equal(or3s(ijj %in% 1:4, , n <= 9L),
bor3(ijj %in% 1:4, , n <= 9L))
expect_equal(or3s(ijk %in% 1:4, w != 0L, ),
bor3(ijk %in% 1:4, w != 0L, ))
expect_equal(or3s(ijl %in% 1:4, v != 1L, ),
bor3(ijl %in% 1:4, v != 1L, ))
expect_equal(or3s(ijm %in% 1:4, y != 9L, ),
bor3(ijm %in% 1:4, y != 9L, ))
expect_equal(or3s(ijn %in% 1:4, v != 0L, y <= 0L),
bor3(ijn %in% 1:4, v != 0L, y <= 0L))
expect_equal(or3s(ijo %in% 1:4, k != 1L, e <= 1L),
bor3(ijo %in% 1:4, k != 1L, e <= 1L))
expect_equal(or3s(ijp %in% 1:4, r != 9L, w <= 9L),
bor3(ijp %in% 1:4, r != 9L, w <= 9L))
expect_equal(or3s(ijq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ijq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ijr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ijr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ijs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ijs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ijt %in% c(4L, -3L, 2L, 7L, 8L), , q == 0L),
bor3(ijt %in% c(4L, -3L, 2L, 7L, 8L), , q == 0L))
expect_equal(or3s(iju %in% c(4L, -3L, 2L, 7L, 8L), , u == 1L),
bor3(iju %in% c(4L, -3L, 2L, 7L, 8L), , u == 1L))
expect_equal(or3s(ijv %in% c(4L, -3L, 2L, 7L, 8L), , f == 9L),
bor3(ijv %in% c(4L, -3L, 2L, 7L, 8L), , f == 9L))
expect_equal(or3s(ijw %in% c(4L, -3L, 2L, 7L, 8L), a != 0L, ),
bor3(ijw %in% c(4L, -3L, 2L, 7L, 8L), a != 0L, ))
expect_equal(or3s(ijx %in% c(4L, -3L, 2L, 7L, 8L), i != 1L, ),
bor3(ijx %in% c(4L, -3L, 2L, 7L, 8L), i != 1L, ))
expect_equal(or3s(ijy %in% c(4L, -3L, 2L, 7L, 8L), l != 9L, ),
bor3(ijy %in% c(4L, -3L, 2L, 7L, 8L), l != 9L, ))
expect_equal(or3s(ijz %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, m == 0L),
bor3(ijz %in% c(4L, -3L, 2L, 7L, 8L), r != 0L, m == 0L))
expect_equal(or3s(ika %in% c(4L, -3L, 2L, 7L, 8L), z != 1L, p == 1L),
bor3(ika %in% c(4L, -3L, 2L, 7L, 8L), z != 1L, p == 1L))
expect_equal(or3s(ikb %in% c(4L, -3L, 2L, 7L, 8L), e != 9L, w == 9L),
bor3(ikb %in% c(4L, -3L, 2L, 7L, 8L), e != 9L, w == 9L))
expect_equal(or3s(ikc %in% 1:4, , ),
bor3(ikc %in% 1:4, , ))
expect_equal(or3s(ikd %in% 1:4, , ),
bor3(ikd %in% 1:4, , ))
expect_equal(or3s(ike %in% 1:4, , ),
bor3(ike %in% 1:4, , ))
expect_equal(or3s(ikf %in% 1:4, , z == 0L),
bor3(ikf %in% 1:4, , z == 0L))
expect_equal(or3s(ikg %in% 1:4, , q == 1L),
bor3(ikg %in% 1:4, , q == 1L))
expect_equal(or3s(ikh %in% 1:4, , n == 9L),
bor3(ikh %in% 1:4, , n == 9L))
expect_equal(or3s(iki %in% 1:4, t != 0L, ),
bor3(iki %in% 1:4, t != 0L, ))
expect_equal(or3s(ikj %in% 1:4, a != 1L, ),
bor3(ikj %in% 1:4, a != 1L, ))
expect_equal(or3s(ikk %in% 1:4, e != 9L, ),
bor3(ikk %in% 1:4, e != 9L, ))
expect_equal(or3s(ikl %in% 1:4, t != 0L, n == 0L),
bor3(ikl %in% 1:4, t != 0L, n == 0L))
expect_equal(or3s(ikm %in% 1:4, t != 1L, l == 1L),
bor3(ikm %in% 1:4, t != 1L, l == 1L))
expect_equal(or3s(ikn %in% 1:4, n != 9L, i == 9L),
bor3(ikn %in% 1:4, n != 9L, i == 9L))
expect_equal(or3s(iko %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iko %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ikp %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ikp %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ikq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ikq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ikr %in% c(4L, -3L, 2L, 7L, 8L), , x > 0L),
bor3(ikr %in% c(4L, -3L, 2L, 7L, 8L), , x > 0L))
expect_equal(or3s(iks %in% c(4L, -3L, 2L, 7L, 8L), , m > 1L),
bor3(iks %in% c(4L, -3L, 2L, 7L, 8L), , m > 1L))
expect_equal(or3s(ikt %in% c(4L, -3L, 2L, 7L, 8L), , n > 9L),
bor3(ikt %in% c(4L, -3L, 2L, 7L, 8L), , n > 9L))
expect_equal(or3s(iku %in% c(4L, -3L, 2L, 7L, 8L), q != 0L, ),
bor3(iku %in% c(4L, -3L, 2L, 7L, 8L), q != 0L, ))
expect_equal(or3s(ikv %in% c(4L, -3L, 2L, 7L, 8L), l != 1L, ),
bor3(ikv %in% c(4L, -3L, 2L, 7L, 8L), l != 1L, ))
expect_equal(or3s(ikw %in% c(4L, -3L, 2L, 7L, 8L), e != 9L, ),
bor3(ikw %in% c(4L, -3L, 2L, 7L, 8L), e != 9L, ))
expect_equal(or3s(ikx %in% c(4L, -3L, 2L, 7L, 8L), l != 0L, c > 0L),
bor3(ikx %in% c(4L, -3L, 2L, 7L, 8L), l != 0L, c > 0L))
expect_equal(or3s(iky %in% c(4L, -3L, 2L, 7L, 8L), f != 1L, a > 1L),
bor3(iky %in% c(4L, -3L, 2L, 7L, 8L), f != 1L, a > 1L))
expect_equal(or3s(ikz %in% c(4L, -3L, 2L, 7L, 8L), j != 9L, p > 9L),
bor3(ikz %in% c(4L, -3L, 2L, 7L, 8L), j != 9L, p > 9L))
expect_equal(or3s(ila %in% 1:4, , ),
bor3(ila %in% 1:4, , ))
expect_equal(or3s(ilb %in% 1:4, , ),
bor3(ilb %in% 1:4, , ))
expect_equal(or3s(ilc %in% 1:4, , ),
bor3(ilc %in% 1:4, , ))
expect_equal(or3s(ild %in% 1:4, , n > 0L),
bor3(ild %in% 1:4, , n > 0L))
expect_equal(or3s(ile %in% 1:4, , s > 1L),
bor3(ile %in% 1:4, , s > 1L))
expect_equal(or3s(ilf %in% 1:4, , y > 9L),
bor3(ilf %in% 1:4, , y > 9L))
expect_equal(or3s(ilg %in% 1:4, l != 0L, ),
bor3(ilg %in% 1:4, l != 0L, ))
expect_equal(or3s(ilh %in% 1:4, m != 1L, ),
bor3(ilh %in% 1:4, m != 1L, ))
expect_equal(or3s(ili %in% 1:4, n != 9L, ),
bor3(ili %in% 1:4, n != 9L, ))
expect_equal(or3s(ilj %in% 1:4, z != 0L, u > 0L),
bor3(ilj %in% 1:4, z != 0L, u > 0L))
expect_equal(or3s(ilk %in% 1:4, p != 1L, z > 1L),
bor3(ilk %in% 1:4, p != 1L, z > 1L))
expect_equal(or3s(ill %in% 1:4, t != 9L, n > 9L),
bor3(ill %in% 1:4, t != 9L, n > 9L))
expect_equal(or3s(ilm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ilm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iln %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iln %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ilo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ilo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ilp %in% c(4L, -3L, 2L, 7L, 8L), , s >= 0L),
bor3(ilp %in% c(4L, -3L, 2L, 7L, 8L), , s >= 0L))
expect_equal(or3s(ilq %in% c(4L, -3L, 2L, 7L, 8L), , w >= 1L),
bor3(ilq %in% c(4L, -3L, 2L, 7L, 8L), , w >= 1L))
expect_equal(or3s(ilr %in% c(4L, -3L, 2L, 7L, 8L), , p >= 9L),
bor3(ilr %in% c(4L, -3L, 2L, 7L, 8L), , p >= 9L))
expect_equal(or3s(ils %in% c(4L, -3L, 2L, 7L, 8L), p != 0L, ),
bor3(ils %in% c(4L, -3L, 2L, 7L, 8L), p != 0L, ))
expect_equal(or3s(ilt %in% c(4L, -3L, 2L, 7L, 8L), s != 1L, ),
bor3(ilt %in% c(4L, -3L, 2L, 7L, 8L), s != 1L, ))
expect_equal(or3s(ilu %in% c(4L, -3L, 2L, 7L, 8L), d != 9L, ),
bor3(ilu %in% c(4L, -3L, 2L, 7L, 8L), d != 9L, ))
expect_equal(or3s(ilv %in% c(4L, -3L, 2L, 7L, 8L), p != 0L, b >= 0L),
bor3(ilv %in% c(4L, -3L, 2L, 7L, 8L), p != 0L, b >= 0L))
expect_equal(or3s(ilw %in% c(4L, -3L, 2L, 7L, 8L), p != 1L, k >= 1L),
bor3(ilw %in% c(4L, -3L, 2L, 7L, 8L), p != 1L, k >= 1L))
expect_equal(or3s(ilx %in% c(4L, -3L, 2L, 7L, 8L), r != 9L, p >= 9L),
bor3(ilx %in% c(4L, -3L, 2L, 7L, 8L), r != 9L, p >= 9L))
expect_equal(or3s(ily %in% 1:4, , ),
bor3(ily %in% 1:4, , ))
expect_equal(or3s(ilz %in% 1:4, , ),
bor3(ilz %in% 1:4, , ))
expect_equal(or3s(ima %in% 1:4, , ),
bor3(ima %in% 1:4, , ))
expect_equal(or3s(imb %in% 1:4, , h >= 0L),
bor3(imb %in% 1:4, , h >= 0L))
expect_equal(or3s(imc %in% 1:4, , r >= 1L),
bor3(imc %in% 1:4, , r >= 1L))
expect_equal(or3s(imd %in% 1:4, , i >= 9L),
bor3(imd %in% 1:4, , i >= 9L))
expect_equal(or3s(ime %in% 1:4, v != 0L, ),
bor3(ime %in% 1:4, v != 0L, ))
expect_equal(or3s(imf %in% 1:4, n != 1L, ),
bor3(imf %in% 1:4, n != 1L, ))
expect_equal(or3s(img %in% 1:4, f != 9L, ),
bor3(img %in% 1:4, f != 9L, ))
expect_equal(or3s(imh %in% 1:4, e != 0L, z >= 0L),
bor3(imh %in% 1:4, e != 0L, z >= 0L))
expect_equal(or3s(imi %in% 1:4, w != 1L, u >= 1L),
bor3(imi %in% 1:4, w != 1L, u >= 1L))
expect_equal(or3s(imj %in% 1:4, i != 9L, e >= 9L),
bor3(imj %in% 1:4, i != 9L, e >= 9L))
expect_equal(or3s(imk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(imk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iml %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iml %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(imm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(imm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(imn %in% c(4L, -3L, 2L, 7L, 8L), , logi_z),
bor3(imn %in% c(4L, -3L, 2L, 7L, 8L), , logi_z))
expect_equal(or3s(imo %in% c(4L, -3L, 2L, 7L, 8L), , logi_l),
bor3(imo %in% c(4L, -3L, 2L, 7L, 8L), , logi_l))
expect_equal(or3s(imp %in% c(4L, -3L, 2L, 7L, 8L), , logi_p),
bor3(imp %in% c(4L, -3L, 2L, 7L, 8L), , logi_p))
expect_equal(or3s(imq %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), ),
bor3(imq %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), ))
expect_equal(or3s(imr %in% c(4L, -3L, 2L, 7L, 8L), g %between% c(-1L, 1L), ),
bor3(imr %in% c(4L, -3L, 2L, 7L, 8L), g %between% c(-1L, 1L), ))
expect_equal(or3s(ims %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L), ),
bor3(ims %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L), ))
expect_equal(or3s(imt %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), logi_g),
bor3(imt %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), logi_g))
expect_equal(or3s(imu %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L), logi_t),
bor3(imu %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L), logi_t))
expect_equal(or3s(imv %in% c(4L, -3L, 2L, 7L, 8L), w %between% c(-1L, 1L), logi_e),
bor3(imv %in% c(4L, -3L, 2L, 7L, 8L), w %between% c(-1L, 1L), logi_e))
expect_equal(or3s(imw %in% 1:4, , ),
bor3(imw %in% 1:4, , ))
expect_equal(or3s(imx %in% 1:4, , ),
bor3(imx %in% 1:4, , ))
expect_equal(or3s(imy %in% 1:4, , ),
bor3(imy %in% 1:4, , ))
expect_equal(or3s(imz %in% 1:4, , logi_y),
bor3(imz %in% 1:4, , logi_y))
expect_equal(or3s(ina %in% 1:4, , logi_u),
bor3(ina %in% 1:4, , logi_u))
expect_equal(or3s(inb %in% 1:4, , logi_y),
bor3(inb %in% 1:4, , logi_y))
expect_equal(or3s(inc %in% 1:4, u %between% c(-1L, 1L), ),
bor3(inc %in% 1:4, u %between% c(-1L, 1L), ))
expect_equal(or3s(ind %in% 1:4, n %between% c(-1L, 1L), ),
bor3(ind %in% 1:4, n %between% c(-1L, 1L), ))
expect_equal(or3s(ine %in% 1:4, j %between% c(-1L, 1L), ),
bor3(ine %in% 1:4, j %between% c(-1L, 1L), ))
expect_equal(or3s(inf %in% 1:4, p %between% c(-1L, 1L), logi_v),
bor3(inf %in% 1:4, p %between% c(-1L, 1L), logi_v))
expect_equal(or3s(ing %in% 1:4, w %between% c(-1L, 1L), logi_f),
bor3(ing %in% 1:4, w %between% c(-1L, 1L), logi_f))
expect_equal(or3s(inh %in% 1:4, q %between% c(-1L, 1L), logi_k),
bor3(inh %in% 1:4, q %between% c(-1L, 1L), logi_k))
expect_equal(or3s(ini %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ini %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(inj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(inj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ink %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ink %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(inl %in% c(4L, -3L, 2L, 7L, 8L), , !logi_w),
bor3(inl %in% c(4L, -3L, 2L, 7L, 8L), , !logi_w))
expect_equal(or3s(inm %in% c(4L, -3L, 2L, 7L, 8L), , !logi_t),
bor3(inm %in% c(4L, -3L, 2L, 7L, 8L), , !logi_t))
expect_equal(or3s(inn %in% c(4L, -3L, 2L, 7L, 8L), , !logi_k),
bor3(inn %in% c(4L, -3L, 2L, 7L, 8L), , !logi_k))
expect_equal(or3s(ino %in% c(4L, -3L, 2L, 7L, 8L), b %between% c(-1L, 1L), ),
bor3(ino %in% c(4L, -3L, 2L, 7L, 8L), b %between% c(-1L, 1L), ))
expect_equal(or3s(inp %in% c(4L, -3L, 2L, 7L, 8L), c %between% c(-1L, 1L), ),
bor3(inp %in% c(4L, -3L, 2L, 7L, 8L), c %between% c(-1L, 1L), ))
expect_equal(or3s(inq %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L), ),
bor3(inq %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L), ))
expect_equal(or3s(inr %in% c(4L, -3L, 2L, 7L, 8L), h %between% c(-1L, 1L), !logi_x),
bor3(inr %in% c(4L, -3L, 2L, 7L, 8L), h %between% c(-1L, 1L), !logi_x))
expect_equal(or3s(ins %in% c(4L, -3L, 2L, 7L, 8L), m %between% c(-1L, 1L), !logi_n),
bor3(ins %in% c(4L, -3L, 2L, 7L, 8L), m %between% c(-1L, 1L), !logi_n))
expect_equal(or3s(int %in% c(4L, -3L, 2L, 7L, 8L), q %between% c(-1L, 1L), !logi_w),
bor3(int %in% c(4L, -3L, 2L, 7L, 8L), q %between% c(-1L, 1L), !logi_w))
expect_equal(or3s(inu %in% 1:4, , ),
bor3(inu %in% 1:4, , ))
expect_equal(or3s(inv %in% 1:4, , ),
bor3(inv %in% 1:4, , ))
expect_equal(or3s(inw %in% 1:4, , ),
bor3(inw %in% 1:4, , ))
expect_equal(or3s(inx %in% 1:4, , !logi_n),
bor3(inx %in% 1:4, , !logi_n))
expect_equal(or3s(iny %in% 1:4, , !logi_b),
bor3(iny %in% 1:4, , !logi_b))
expect_equal(or3s(inz %in% 1:4, , !logi_d),
bor3(inz %in% 1:4, , !logi_d))
expect_equal(or3s(ioa %in% 1:4, g %between% c(-1L, 1L), ),
bor3(ioa %in% 1:4, g %between% c(-1L, 1L), ))
expect_equal(or3s(iob %in% 1:4, u %between% c(-1L, 1L), ),
bor3(iob %in% 1:4, u %between% c(-1L, 1L), ))
expect_equal(or3s(ioc %in% 1:4, g %between% c(-1L, 1L), ),
bor3(ioc %in% 1:4, g %between% c(-1L, 1L), ))
expect_equal(or3s(iod %in% 1:4, n %between% c(-1L, 1L), !logi_b),
bor3(iod %in% 1:4, n %between% c(-1L, 1L), !logi_b))
expect_equal(or3s(ioe %in% 1:4, s %between% c(-1L, 1L), !logi_s),
bor3(ioe %in% 1:4, s %between% c(-1L, 1L), !logi_s))
expect_equal(or3s(iof %in% 1:4, o %between% c(-1L, 1L), !logi_p),
bor3(iof %in% 1:4, o %between% c(-1L, 1L), !logi_p))
expect_equal(or3s(iog %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iog %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ioh %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ioh %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ioi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ioi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ioj %in% c(4L, -3L, 2L, 7L, 8L), , d != 0L),
bor3(ioj %in% c(4L, -3L, 2L, 7L, 8L), , d != 0L))
expect_equal(or3s(iok %in% c(4L, -3L, 2L, 7L, 8L), , j != 1L),
bor3(iok %in% c(4L, -3L, 2L, 7L, 8L), , j != 1L))
expect_equal(or3s(iol %in% c(4L, -3L, 2L, 7L, 8L), , i != 9L),
bor3(iol %in% c(4L, -3L, 2L, 7L, 8L), , i != 9L))
expect_equal(or3s(iom %in% c(4L, -3L, 2L, 7L, 8L), s %between% c(-1L, 1L), ),
bor3(iom %in% c(4L, -3L, 2L, 7L, 8L), s %between% c(-1L, 1L), ))
expect_equal(or3s(ion %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), ),
bor3(ion %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), ))
expect_equal(or3s(ioo %in% c(4L, -3L, 2L, 7L, 8L), x %between% c(-1L, 1L), ),
bor3(ioo %in% c(4L, -3L, 2L, 7L, 8L), x %between% c(-1L, 1L), ))
expect_equal(or3s(iop %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), h != 0L),
bor3(iop %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), h != 0L))
expect_equal(or3s(ioq %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L), y != 1L),
bor3(ioq %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L), y != 1L))
expect_equal(or3s(ior %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L), a != 9L),
bor3(ior %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L), a != 9L))
expect_equal(or3s(ios %in% 1:4, , ),
bor3(ios %in% 1:4, , ))
expect_equal(or3s(iot %in% 1:4, , ),
bor3(iot %in% 1:4, , ))
expect_equal(or3s(iou %in% 1:4, , ),
bor3(iou %in% 1:4, , ))
expect_equal(or3s(iov %in% 1:4, , q != 0L),
bor3(iov %in% 1:4, , q != 0L))
expect_equal(or3s(iow %in% 1:4, , w != 1L),
bor3(iow %in% 1:4, , w != 1L))
expect_equal(or3s(iox %in% 1:4, , l != 9L),
bor3(iox %in% 1:4, , l != 9L))
expect_equal(or3s(ioy %in% 1:4, n %between% c(-1L, 1L), ),
bor3(ioy %in% 1:4, n %between% c(-1L, 1L), ))
expect_equal(or3s(ioz %in% 1:4, t %between% c(-1L, 1L), ),
bor3(ioz %in% 1:4, t %between% c(-1L, 1L), ))
expect_equal(or3s(ipa %in% 1:4, l %between% c(-1L, 1L), ),
bor3(ipa %in% 1:4, l %between% c(-1L, 1L), ))
expect_equal(or3s(ipb %in% 1:4, j %between% c(-1L, 1L), g != 0L),
bor3(ipb %in% 1:4, j %between% c(-1L, 1L), g != 0L))
expect_equal(or3s(ipc %in% 1:4, j %between% c(-1L, 1L), k != 1L),
bor3(ipc %in% 1:4, j %between% c(-1L, 1L), k != 1L))
expect_equal(or3s(ipd %in% 1:4, g %between% c(-1L, 1L), b != 9L),
bor3(ipd %in% 1:4, g %between% c(-1L, 1L), b != 9L))
expect_equal(or3s(ipe %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ipe %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ipf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ipf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ipg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ipg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iph %in% c(4L, -3L, 2L, 7L, 8L), , p %between% c(-1L, 1L)),
bor3(iph %in% c(4L, -3L, 2L, 7L, 8L), , p %between% c(-1L, 1L)))
expect_equal(or3s(ipi %in% c(4L, -3L, 2L, 7L, 8L), , w %between% c(-1L, 1L)),
bor3(ipi %in% c(4L, -3L, 2L, 7L, 8L), , w %between% c(-1L, 1L)))
expect_equal(or3s(ipj %in% c(4L, -3L, 2L, 7L, 8L), , j %between% c(-1L, 1L)),
bor3(ipj %in% c(4L, -3L, 2L, 7L, 8L), , j %between% c(-1L, 1L)))
expect_equal(or3s(ipk %in% c(4L, -3L, 2L, 7L, 8L), f %between% c(-1L, 1L), ),
bor3(ipk %in% c(4L, -3L, 2L, 7L, 8L), f %between% c(-1L, 1L), ))
expect_equal(or3s(ipl %in% c(4L, -3L, 2L, 7L, 8L), s %between% c(-1L, 1L), ),
bor3(ipl %in% c(4L, -3L, 2L, 7L, 8L), s %between% c(-1L, 1L), ))
expect_equal(or3s(ipm %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), ),
bor3(ipm %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), ))
expect_equal(or3s(ipn %in% c(4L, -3L, 2L, 7L, 8L), q %between% c(-1L, 1L), p %between% c(-1L, 1L)),
bor3(ipn %in% c(4L, -3L, 2L, 7L, 8L), q %between% c(-1L, 1L), p %between% c(-1L, 1L)))
expect_equal(or3s(ipo %in% c(4L, -3L, 2L, 7L, 8L), w %between% c(-1L, 1L), y %between% c(-1L, 1L)),
bor3(ipo %in% c(4L, -3L, 2L, 7L, 8L), w %between% c(-1L, 1L), y %between% c(-1L, 1L)))
expect_equal(or3s(ipp %in% c(4L, -3L, 2L, 7L, 8L), i %between% c(-1L, 1L), t %between% c(-1L, 1L)),
bor3(ipp %in% c(4L, -3L, 2L, 7L, 8L), i %between% c(-1L, 1L), t %between% c(-1L, 1L)))
expect_equal(or3s(ipq %in% 1:4, , ),
bor3(ipq %in% 1:4, , ))
expect_equal(or3s(ipr %in% 1:4, , ),
bor3(ipr %in% 1:4, , ))
expect_equal(or3s(ips %in% 1:4, , ),
bor3(ips %in% 1:4, , ))
expect_equal(or3s(ipt %in% 1:4, , f %between% c(-1L, 1L)),
bor3(ipt %in% 1:4, , f %between% c(-1L, 1L)))
expect_equal(or3s(ipu %in% 1:4, , u %between% c(-1L, 1L)),
bor3(ipu %in% 1:4, , u %between% c(-1L, 1L)))
expect_equal(or3s(ipv %in% 1:4, , l %between% c(-1L, 1L)),
bor3(ipv %in% 1:4, , l %between% c(-1L, 1L)))
expect_equal(or3s(ipw %in% 1:4, k %between% c(-1L, 1L), ),
bor3(ipw %in% 1:4, k %between% c(-1L, 1L), ))
expect_equal(or3s(ipx %in% 1:4, v %between% c(-1L, 1L), ),
bor3(ipx %in% 1:4, v %between% c(-1L, 1L), ))
expect_equal(or3s(ipy %in% 1:4, p %between% c(-1L, 1L), ),
bor3(ipy %in% 1:4, p %between% c(-1L, 1L), ))
expect_equal(or3s(ipz %in% 1:4, d %between% c(-1L, 1L), a %between% c(-1L, 1L)),
bor3(ipz %in% 1:4, d %between% c(-1L, 1L), a %between% c(-1L, 1L)))
expect_equal(or3s(iqa %in% 1:4, v %between% c(-1L, 1L), b %between% c(-1L, 1L)),
bor3(iqa %in% 1:4, v %between% c(-1L, 1L), b %between% c(-1L, 1L)))
expect_equal(or3s(iqb %in% 1:4, m %between% c(-1L, 1L), r %between% c(-1L, 1L)),
bor3(iqb %in% 1:4, m %between% c(-1L, 1L), r %between% c(-1L, 1L)))
expect_equal(or3s(iqc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iqc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iqd %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iqd %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iqe %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iqe %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iqf %in% c(4L, -3L, 2L, 7L, 8L), , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iqf %in% c(4L, -3L, 2L, 7L, 8L), , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iqg %in% c(4L, -3L, 2L, 7L, 8L), , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iqg %in% c(4L, -3L, 2L, 7L, 8L), , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iqh %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iqh %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iqi %in% c(4L, -3L, 2L, 7L, 8L), d %between% c(-1L, 1L), ),
bor3(iqi %in% c(4L, -3L, 2L, 7L, 8L), d %between% c(-1L, 1L), ))
expect_equal(or3s(iqj %in% c(4L, -3L, 2L, 7L, 8L), d %between% c(-1L, 1L), ),
bor3(iqj %in% c(4L, -3L, 2L, 7L, 8L), d %between% c(-1L, 1L), ))
expect_equal(or3s(iqk %in% c(4L, -3L, 2L, 7L, 8L), v %between% c(-1L, 1L), ),
bor3(iqk %in% c(4L, -3L, 2L, 7L, 8L), v %between% c(-1L, 1L), ))
expect_equal(or3s(iql %in% c(4L, -3L, 2L, 7L, 8L), f %between% c(-1L, 1L), u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iql %in% c(4L, -3L, 2L, 7L, 8L), f %between% c(-1L, 1L), u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iqm %in% c(4L, -3L, 2L, 7L, 8L), o %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iqm %in% c(4L, -3L, 2L, 7L, 8L), o %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iqn %in% c(4L, -3L, 2L, 7L, 8L), z %between% c(-1L, 1L), k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(iqn %in% c(4L, -3L, 2L, 7L, 8L), z %between% c(-1L, 1L), k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(iqo %in% 1:4, , ),
bor3(iqo %in% 1:4, , ))
expect_equal(or3s(iqp %in% 1:4, , ),
bor3(iqp %in% 1:4, , ))
expect_equal(or3s(iqq %in% 1:4, , ),
bor3(iqq %in% 1:4, , ))
expect_equal(or3s(iqr %in% 1:4, , o %in% 1:4),
bor3(iqr %in% 1:4, , o %in% 1:4))
expect_equal(or3s(iqs %in% 1:4, , o %in% 1:4),
bor3(iqs %in% 1:4, , o %in% 1:4))
expect_equal(or3s(iqt %in% 1:4, , p %in% 1:4),
bor3(iqt %in% 1:4, , p %in% 1:4))
expect_equal(or3s(iqu %in% 1:4, j %between% c(-1L, 1L), ),
bor3(iqu %in% 1:4, j %between% c(-1L, 1L), ))
expect_equal(or3s(iqv %in% 1:4, s %between% c(-1L, 1L), ),
bor3(iqv %in% 1:4, s %between% c(-1L, 1L), ))
expect_equal(or3s(iqw %in% 1:4, d %between% c(-1L, 1L), ),
bor3(iqw %in% 1:4, d %between% c(-1L, 1L), ))
expect_equal(or3s(iqx %in% 1:4, x %between% c(-1L, 1L), x %in% 1:4),
bor3(iqx %in% 1:4, x %between% c(-1L, 1L), x %in% 1:4))
expect_equal(or3s(iqy %in% 1:4, c %between% c(-1L, 1L), h %in% 1:4),
bor3(iqy %in% 1:4, c %between% c(-1L, 1L), h %in% 1:4))
expect_equal(or3s(iqz %in% 1:4, m %between% c(-1L, 1L), l %in% 1:4),
bor3(iqz %in% 1:4, m %between% c(-1L, 1L), l %in% 1:4))
expect_equal(or3s(ira %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ira %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(irb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(irb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(irc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(irc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ird %in% c(4L, -3L, 2L, 7L, 8L), , o < 0L),
bor3(ird %in% c(4L, -3L, 2L, 7L, 8L), , o < 0L))
expect_equal(or3s(ire %in% c(4L, -3L, 2L, 7L, 8L), , d < 1L),
bor3(ire %in% c(4L, -3L, 2L, 7L, 8L), , d < 1L))
expect_equal(or3s(irf %in% c(4L, -3L, 2L, 7L, 8L), , y < 9L),
bor3(irf %in% c(4L, -3L, 2L, 7L, 8L), , y < 9L))
expect_equal(or3s(irg %in% c(4L, -3L, 2L, 7L, 8L), z %between% c(-1L, 1L), ),
bor3(irg %in% c(4L, -3L, 2L, 7L, 8L), z %between% c(-1L, 1L), ))
expect_equal(or3s(irh %in% c(4L, -3L, 2L, 7L, 8L), v %between% c(-1L, 1L), ),
bor3(irh %in% c(4L, -3L, 2L, 7L, 8L), v %between% c(-1L, 1L), ))
expect_equal(or3s(iri %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ),
bor3(iri %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ))
expect_equal(or3s(irj %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), q < 0L),
bor3(irj %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), q < 0L))
expect_equal(or3s(irk %in% c(4L, -3L, 2L, 7L, 8L), q %between% c(-1L, 1L), i < 1L),
bor3(irk %in% c(4L, -3L, 2L, 7L, 8L), q %between% c(-1L, 1L), i < 1L))
expect_equal(or3s(irl %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), k < 9L),
bor3(irl %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), k < 9L))
expect_equal(or3s(irm %in% 1:4, , ),
bor3(irm %in% 1:4, , ))
expect_equal(or3s(irn %in% 1:4, , ),
bor3(irn %in% 1:4, , ))
expect_equal(or3s(iro %in% 1:4, , ),
bor3(iro %in% 1:4, , ))
expect_equal(or3s(irp %in% 1:4, , h < 0L),
bor3(irp %in% 1:4, , h < 0L))
expect_equal(or3s(irq %in% 1:4, , p < 1L),
bor3(irq %in% 1:4, , p < 1L))
expect_equal(or3s(irr %in% 1:4, , n < 9L),
bor3(irr %in% 1:4, , n < 9L))
expect_equal(or3s(irs %in% 1:4, y %between% c(-1L, 1L), ),
bor3(irs %in% 1:4, y %between% c(-1L, 1L), ))
expect_equal(or3s(irt %in% 1:4, v %between% c(-1L, 1L), ),
bor3(irt %in% 1:4, v %between% c(-1L, 1L), ))
expect_equal(or3s(iru %in% 1:4, j %between% c(-1L, 1L), ),
bor3(iru %in% 1:4, j %between% c(-1L, 1L), ))
expect_equal(or3s(irv %in% 1:4, s %between% c(-1L, 1L), q < 0L),
bor3(irv %in% 1:4, s %between% c(-1L, 1L), q < 0L))
expect_equal(or3s(irw %in% 1:4, w %between% c(-1L, 1L), f < 1L),
bor3(irw %in% 1:4, w %between% c(-1L, 1L), f < 1L))
expect_equal(or3s(irx %in% 1:4, i %between% c(-1L, 1L), t < 9L),
bor3(irx %in% 1:4, i %between% c(-1L, 1L), t < 9L))
expect_equal(or3s(iry %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iry %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(irz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(irz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(isa %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(isa %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(isb %in% c(4L, -3L, 2L, 7L, 8L), , c <= 0L),
bor3(isb %in% c(4L, -3L, 2L, 7L, 8L), , c <= 0L))
expect_equal(or3s(isc %in% c(4L, -3L, 2L, 7L, 8L), , k <= 1L),
bor3(isc %in% c(4L, -3L, 2L, 7L, 8L), , k <= 1L))
expect_equal(or3s(isd %in% c(4L, -3L, 2L, 7L, 8L), , r <= 9L),
bor3(isd %in% c(4L, -3L, 2L, 7L, 8L), , r <= 9L))
expect_equal(or3s(ise %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ),
bor3(ise %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ))
expect_equal(or3s(isf %in% c(4L, -3L, 2L, 7L, 8L), h %between% c(-1L, 1L), ),
bor3(isf %in% c(4L, -3L, 2L, 7L, 8L), h %between% c(-1L, 1L), ))
expect_equal(or3s(isg %in% c(4L, -3L, 2L, 7L, 8L), c %between% c(-1L, 1L), ),
bor3(isg %in% c(4L, -3L, 2L, 7L, 8L), c %between% c(-1L, 1L), ))
expect_equal(or3s(ish %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), i <= 0L),
bor3(ish %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), i <= 0L))
expect_equal(or3s(isi %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), w <= 1L),
bor3(isi %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), w <= 1L))
expect_equal(or3s(isj %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), u <= 9L),
bor3(isj %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), u <= 9L))
expect_equal(or3s(isk %in% 1:4, , ),
bor3(isk %in% 1:4, , ))
expect_equal(or3s(isl %in% 1:4, , ),
bor3(isl %in% 1:4, , ))
expect_equal(or3s(ism %in% 1:4, , ),
bor3(ism %in% 1:4, , ))
expect_equal(or3s(isn %in% 1:4, , o <= 0L),
bor3(isn %in% 1:4, , o <= 0L))
expect_equal(or3s(iso %in% 1:4, , p <= 1L),
bor3(iso %in% 1:4, , p <= 1L))
expect_equal(or3s(isp %in% 1:4, , m <= 9L),
bor3(isp %in% 1:4, , m <= 9L))
expect_equal(or3s(isq %in% 1:4, l %between% c(-1L, 1L), ),
bor3(isq %in% 1:4, l %between% c(-1L, 1L), ))
expect_equal(or3s(isr %in% 1:4, j %between% c(-1L, 1L), ),
bor3(isr %in% 1:4, j %between% c(-1L, 1L), ))
expect_equal(or3s(iss %in% 1:4, f %between% c(-1L, 1L), ),
bor3(iss %in% 1:4, f %between% c(-1L, 1L), ))
expect_equal(or3s(ist %in% 1:4, b %between% c(-1L, 1L), j <= 0L),
bor3(ist %in% 1:4, b %between% c(-1L, 1L), j <= 0L))
expect_equal(or3s(isu %in% 1:4, q %between% c(-1L, 1L), k <= 1L),
bor3(isu %in% 1:4, q %between% c(-1L, 1L), k <= 1L))
expect_equal(or3s(isv %in% 1:4, e %between% c(-1L, 1L), d <= 9L),
bor3(isv %in% 1:4, e %between% c(-1L, 1L), d <= 9L))
expect_equal(or3s(isw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(isw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(isx %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(isx %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(isy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(isy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(isz %in% c(4L, -3L, 2L, 7L, 8L), , y == 0L),
bor3(isz %in% c(4L, -3L, 2L, 7L, 8L), , y == 0L))
expect_equal(or3s(ita %in% c(4L, -3L, 2L, 7L, 8L), , q == 1L),
bor3(ita %in% c(4L, -3L, 2L, 7L, 8L), , q == 1L))
expect_equal(or3s(itb %in% c(4L, -3L, 2L, 7L, 8L), , v == 9L),
bor3(itb %in% c(4L, -3L, 2L, 7L, 8L), , v == 9L))
expect_equal(or3s(itc %in% c(4L, -3L, 2L, 7L, 8L), p %between% c(-1L, 1L), ),
bor3(itc %in% c(4L, -3L, 2L, 7L, 8L), p %between% c(-1L, 1L), ))
expect_equal(or3s(itd %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ),
bor3(itd %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ))
expect_equal(or3s(ite %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), ),
bor3(ite %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), ))
expect_equal(or3s(itf %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L), m == 0L),
bor3(itf %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L), m == 0L))
expect_equal(or3s(itg %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L), e == 1L),
bor3(itg %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L), e == 1L))
expect_equal(or3s(ith %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), b == 9L),
bor3(ith %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), b == 9L))
expect_equal(or3s(iti %in% 1:4, , ),
bor3(iti %in% 1:4, , ))
expect_equal(or3s(itj %in% 1:4, , ),
bor3(itj %in% 1:4, , ))
expect_equal(or3s(itk %in% 1:4, , ),
bor3(itk %in% 1:4, , ))
expect_equal(or3s(itl %in% 1:4, , k == 0L),
bor3(itl %in% 1:4, , k == 0L))
expect_equal(or3s(itm %in% 1:4, , k == 1L),
bor3(itm %in% 1:4, , k == 1L))
expect_equal(or3s(itn %in% 1:4, , o == 9L),
bor3(itn %in% 1:4, , o == 9L))
expect_equal(or3s(ito %in% 1:4, r %between% c(-1L, 1L), ),
bor3(ito %in% 1:4, r %between% c(-1L, 1L), ))
expect_equal(or3s(itp %in% 1:4, q %between% c(-1L, 1L), ),
bor3(itp %in% 1:4, q %between% c(-1L, 1L), ))
expect_equal(or3s(itq %in% 1:4, x %between% c(-1L, 1L), ),
bor3(itq %in% 1:4, x %between% c(-1L, 1L), ))
expect_equal(or3s(itr %in% 1:4, j %between% c(-1L, 1L), t == 0L),
bor3(itr %in% 1:4, j %between% c(-1L, 1L), t == 0L))
expect_equal(or3s(its %in% 1:4, k %between% c(-1L, 1L), n == 1L),
bor3(its %in% 1:4, k %between% c(-1L, 1L), n == 1L))
expect_equal(or3s(itt %in% 1:4, r %between% c(-1L, 1L), g == 9L),
bor3(itt %in% 1:4, r %between% c(-1L, 1L), g == 9L))
expect_equal(or3s(itu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(itu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(itv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(itv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(itw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(itw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(itx %in% c(4L, -3L, 2L, 7L, 8L), , c > 0L),
bor3(itx %in% c(4L, -3L, 2L, 7L, 8L), , c > 0L))
expect_equal(or3s(ity %in% c(4L, -3L, 2L, 7L, 8L), , e > 1L),
bor3(ity %in% c(4L, -3L, 2L, 7L, 8L), , e > 1L))
expect_equal(or3s(itz %in% c(4L, -3L, 2L, 7L, 8L), , p > 9L),
bor3(itz %in% c(4L, -3L, 2L, 7L, 8L), , p > 9L))
expect_equal(or3s(iua %in% c(4L, -3L, 2L, 7L, 8L), b %between% c(-1L, 1L), ),
bor3(iua %in% c(4L, -3L, 2L, 7L, 8L), b %between% c(-1L, 1L), ))
expect_equal(or3s(iub %in% c(4L, -3L, 2L, 7L, 8L), x %between% c(-1L, 1L), ),
bor3(iub %in% c(4L, -3L, 2L, 7L, 8L), x %between% c(-1L, 1L), ))
expect_equal(or3s(iuc %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ),
bor3(iuc %in% c(4L, -3L, 2L, 7L, 8L), k %between% c(-1L, 1L), ))
expect_equal(or3s(iud %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), b > 0L),
bor3(iud %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L), b > 0L))
expect_equal(or3s(iue %in% c(4L, -3L, 2L, 7L, 8L), p %between% c(-1L, 1L), x > 1L),
bor3(iue %in% c(4L, -3L, 2L, 7L, 8L), p %between% c(-1L, 1L), x > 1L))
expect_equal(or3s(iuf %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), e > 9L),
bor3(iuf %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), e > 9L))
expect_equal(or3s(iug %in% 1:4, , ),
bor3(iug %in% 1:4, , ))
expect_equal(or3s(iuh %in% 1:4, , ),
bor3(iuh %in% 1:4, , ))
expect_equal(or3s(iui %in% 1:4, , ),
bor3(iui %in% 1:4, , ))
expect_equal(or3s(iuj %in% 1:4, , s > 0L),
bor3(iuj %in% 1:4, , s > 0L))
expect_equal(or3s(iuk %in% 1:4, , w > 1L),
bor3(iuk %in% 1:4, , w > 1L))
expect_equal(or3s(iul %in% 1:4, , z > 9L),
bor3(iul %in% 1:4, , z > 9L))
expect_equal(or3s(ium %in% 1:4, q %between% c(-1L, 1L), ),
bor3(ium %in% 1:4, q %between% c(-1L, 1L), ))
expect_equal(or3s(iun %in% 1:4, o %between% c(-1L, 1L), ),
bor3(iun %in% 1:4, o %between% c(-1L, 1L), ))
expect_equal(or3s(iuo %in% 1:4, t %between% c(-1L, 1L), ),
bor3(iuo %in% 1:4, t %between% c(-1L, 1L), ))
expect_equal(or3s(iup %in% 1:4, j %between% c(-1L, 1L), a > 0L),
bor3(iup %in% 1:4, j %between% c(-1L, 1L), a > 0L))
expect_equal(or3s(iuq %in% 1:4, d %between% c(-1L, 1L), i > 1L),
bor3(iuq %in% 1:4, d %between% c(-1L, 1L), i > 1L))
expect_equal(or3s(iur %in% 1:4, x %between% c(-1L, 1L), i > 9L),
bor3(iur %in% 1:4, x %between% c(-1L, 1L), i > 9L))
expect_equal(or3s(ius %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ius %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iut %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iut %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iuu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iuu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iuv %in% c(4L, -3L, 2L, 7L, 8L), , z >= 0L),
bor3(iuv %in% c(4L, -3L, 2L, 7L, 8L), , z >= 0L))
expect_equal(or3s(iuw %in% c(4L, -3L, 2L, 7L, 8L), , j >= 1L),
bor3(iuw %in% c(4L, -3L, 2L, 7L, 8L), , j >= 1L))
expect_equal(or3s(iux %in% c(4L, -3L, 2L, 7L, 8L), , l >= 9L),
bor3(iux %in% c(4L, -3L, 2L, 7L, 8L), , l >= 9L))
expect_equal(or3s(iuy %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), ),
bor3(iuy %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L), ))
expect_equal(or3s(iuz %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L), ),
bor3(iuz %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L), ))
expect_equal(or3s(iva %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), ),
bor3(iva %in% c(4L, -3L, 2L, 7L, 8L), j %between% c(-1L, 1L), ))
expect_equal(or3s(ivb %in% c(4L, -3L, 2L, 7L, 8L), a %between% c(-1L, 1L), z >= 0L),
bor3(ivb %in% c(4L, -3L, 2L, 7L, 8L), a %between% c(-1L, 1L), z >= 0L))
expect_equal(or3s(ivc %in% c(4L, -3L, 2L, 7L, 8L), i %between% c(-1L, 1L), c >= 1L),
bor3(ivc %in% c(4L, -3L, 2L, 7L, 8L), i %between% c(-1L, 1L), c >= 1L))
expect_equal(or3s(ivd %in% c(4L, -3L, 2L, 7L, 8L), g %between% c(-1L, 1L), k >= 9L),
bor3(ivd %in% c(4L, -3L, 2L, 7L, 8L), g %between% c(-1L, 1L), k >= 9L))
expect_equal(or3s(ive %in% 1:4, , ),
bor3(ive %in% 1:4, , ))
expect_equal(or3s(ivf %in% 1:4, , ),
bor3(ivf %in% 1:4, , ))
expect_equal(or3s(ivg %in% 1:4, , ),
bor3(ivg %in% 1:4, , ))
expect_equal(or3s(ivh %in% 1:4, , l >= 0L),
bor3(ivh %in% 1:4, , l >= 0L))
expect_equal(or3s(ivi %in% 1:4, , w >= 1L),
bor3(ivi %in% 1:4, , w >= 1L))
expect_equal(or3s(ivj %in% 1:4, , e >= 9L),
bor3(ivj %in% 1:4, , e >= 9L))
expect_equal(or3s(ivk %in% 1:4, x %between% c(-1L, 1L), ),
bor3(ivk %in% 1:4, x %between% c(-1L, 1L), ))
expect_equal(or3s(ivl %in% 1:4, a %between% c(-1L, 1L), ),
bor3(ivl %in% 1:4, a %between% c(-1L, 1L), ))
expect_equal(or3s(ivm %in% 1:4, a %between% c(-1L, 1L), ),
bor3(ivm %in% 1:4, a %between% c(-1L, 1L), ))
expect_equal(or3s(ivn %in% 1:4, s %between% c(-1L, 1L), e >= 0L),
bor3(ivn %in% 1:4, s %between% c(-1L, 1L), e >= 0L))
expect_equal(or3s(ivo %in% 1:4, r %between% c(-1L, 1L), j >= 1L),
bor3(ivo %in% 1:4, r %between% c(-1L, 1L), j >= 1L))
expect_equal(or3s(ivp %in% 1:4, u %between% c(-1L, 1L), l >= 9L),
bor3(ivp %in% 1:4, u %between% c(-1L, 1L), l >= 9L))
expect_equal(or3s(ivq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ivq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ivr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ivr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ivs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ivs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ivt %in% c(4L, -3L, 2L, 7L, 8L), , logi_h),
bor3(ivt %in% c(4L, -3L, 2L, 7L, 8L), , logi_h))
expect_equal(or3s(ivu %in% c(4L, -3L, 2L, 7L, 8L), , logi_o),
bor3(ivu %in% c(4L, -3L, 2L, 7L, 8L), , logi_o))
expect_equal(or3s(ivv %in% c(4L, -3L, 2L, 7L, 8L), , logi_q),
bor3(ivv %in% c(4L, -3L, 2L, 7L, 8L), , logi_q))
expect_equal(or3s(ivw %in% c(4L, -3L, 2L, 7L, 8L), o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ivw %in% c(4L, -3L, 2L, 7L, 8L), o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ivx %in% c(4L, -3L, 2L, 7L, 8L), z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ivx %in% c(4L, -3L, 2L, 7L, 8L), z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ivy %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ivy %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ivz %in% c(4L, -3L, 2L, 7L, 8L), p %in% c(4L, -3L, 2L, 7L, 8L), logi_l),
bor3(ivz %in% c(4L, -3L, 2L, 7L, 8L), p %in% c(4L, -3L, 2L, 7L, 8L), logi_l))
expect_equal(or3s(iwa %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L), logi_i),
bor3(iwa %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L), logi_i))
expect_equal(or3s(iwb %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), logi_c),
bor3(iwb %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), logi_c))
expect_equal(or3s(iwc %in% 1:4, , ),
bor3(iwc %in% 1:4, , ))
expect_equal(or3s(iwd %in% 1:4, , ),
bor3(iwd %in% 1:4, , ))
expect_equal(or3s(iwe %in% 1:4, , ),
bor3(iwe %in% 1:4, , ))
expect_equal(or3s(iwf %in% 1:4, , logi_v),
bor3(iwf %in% 1:4, , logi_v))
expect_equal(or3s(iwg %in% 1:4, , logi_k),
bor3(iwg %in% 1:4, , logi_k))
expect_equal(or3s(iwh %in% 1:4, , logi_z),
bor3(iwh %in% 1:4, , logi_z))
expect_equal(or3s(iwi %in% 1:4, v %in% 1:4, ),
bor3(iwi %in% 1:4, v %in% 1:4, ))
expect_equal(or3s(iwj %in% 1:4, c %in% 1:4, ),
bor3(iwj %in% 1:4, c %in% 1:4, ))
expect_equal(or3s(iwk %in% 1:4, h %in% 1:4, ),
bor3(iwk %in% 1:4, h %in% 1:4, ))
expect_equal(or3s(iwl %in% 1:4, i %in% 1:4, logi_n),
bor3(iwl %in% 1:4, i %in% 1:4, logi_n))
expect_equal(or3s(iwm %in% 1:4, n %in% 1:4, logi_s),
bor3(iwm %in% 1:4, n %in% 1:4, logi_s))
expect_equal(or3s(iwn %in% 1:4, x %in% 1:4, logi_t),
bor3(iwn %in% 1:4, x %in% 1:4, logi_t))
expect_equal(or3s(iwo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iwo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iwp %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iwp %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iwq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iwq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iwr %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a),
bor3(iwr %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a))
expect_equal(or3s(iws %in% c(4L, -3L, 2L, 7L, 8L), , !logi_t),
bor3(iws %in% c(4L, -3L, 2L, 7L, 8L), , !logi_t))
expect_equal(or3s(iwt %in% c(4L, -3L, 2L, 7L, 8L), , !logi_z),
bor3(iwt %in% c(4L, -3L, 2L, 7L, 8L), , !logi_z))
expect_equal(or3s(iwu %in% c(4L, -3L, 2L, 7L, 8L), s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(iwu %in% c(4L, -3L, 2L, 7L, 8L), s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(iwv %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(iwv %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(iww %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(iww %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(iwx %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), !logi_k),
bor3(iwx %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), !logi_k))
expect_equal(or3s(iwy %in% c(4L, -3L, 2L, 7L, 8L), b %in% c(4L, -3L, 2L, 7L, 8L), !logi_k),
bor3(iwy %in% c(4L, -3L, 2L, 7L, 8L), b %in% c(4L, -3L, 2L, 7L, 8L), !logi_k))
expect_equal(or3s(iwz %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), !logi_x),
bor3(iwz %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), !logi_x))
expect_equal(or3s(ixa %in% 1:4, , ),
bor3(ixa %in% 1:4, , ))
expect_equal(or3s(ixb %in% 1:4, , ),
bor3(ixb %in% 1:4, , ))
expect_equal(or3s(ixc %in% 1:4, , ),
bor3(ixc %in% 1:4, , ))
expect_equal(or3s(ixd %in% 1:4, , !logi_r),
bor3(ixd %in% 1:4, , !logi_r))
expect_equal(or3s(ixe %in% 1:4, , !logi_b),
bor3(ixe %in% 1:4, , !logi_b))
expect_equal(or3s(ixf %in% 1:4, , !logi_d),
bor3(ixf %in% 1:4, , !logi_d))
expect_equal(or3s(ixg %in% 1:4, f %in% 1:4, ),
bor3(ixg %in% 1:4, f %in% 1:4, ))
expect_equal(or3s(ixh %in% 1:4, y %in% 1:4, ),
bor3(ixh %in% 1:4, y %in% 1:4, ))
expect_equal(or3s(ixi %in% 1:4, q %in% 1:4, ),
bor3(ixi %in% 1:4, q %in% 1:4, ))
expect_equal(or3s(ixj %in% 1:4, z %in% 1:4, !logi_v),
bor3(ixj %in% 1:4, z %in% 1:4, !logi_v))
expect_equal(or3s(ixk %in% 1:4, h %in% 1:4, !logi_y),
bor3(ixk %in% 1:4, h %in% 1:4, !logi_y))
expect_equal(or3s(ixl %in% 1:4, o %in% 1:4, !logi_q),
bor3(ixl %in% 1:4, o %in% 1:4, !logi_q))
expect_equal(or3s(ixm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ixm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ixn %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ixn %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ixo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ixo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ixp %in% c(4L, -3L, 2L, 7L, 8L), , m != 0L),
bor3(ixp %in% c(4L, -3L, 2L, 7L, 8L), , m != 0L))
expect_equal(or3s(ixq %in% c(4L, -3L, 2L, 7L, 8L), , q != 1L),
bor3(ixq %in% c(4L, -3L, 2L, 7L, 8L), , q != 1L))
expect_equal(or3s(ixr %in% c(4L, -3L, 2L, 7L, 8L), , v != 9L),
bor3(ixr %in% c(4L, -3L, 2L, 7L, 8L), , v != 9L))
expect_equal(or3s(ixs %in% c(4L, -3L, 2L, 7L, 8L), a %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ixs %in% c(4L, -3L, 2L, 7L, 8L), a %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ixt %in% c(4L, -3L, 2L, 7L, 8L), p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ixt %in% c(4L, -3L, 2L, 7L, 8L), p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ixu %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ixu %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ixv %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), c != 0L),
bor3(ixv %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), c != 0L))
expect_equal(or3s(ixw %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L), z != 1L),
bor3(ixw %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L), z != 1L))
expect_equal(or3s(ixx %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L), k != 9L),
bor3(ixx %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L), k != 9L))
expect_equal(or3s(ixy %in% 1:4, , ),
bor3(ixy %in% 1:4, , ))
expect_equal(or3s(ixz %in% 1:4, , ),
bor3(ixz %in% 1:4, , ))
expect_equal(or3s(iya %in% 1:4, , ),
bor3(iya %in% 1:4, , ))
expect_equal(or3s(iyb %in% 1:4, , r != 0L),
bor3(iyb %in% 1:4, , r != 0L))
expect_equal(or3s(iyc %in% 1:4, , i != 1L),
bor3(iyc %in% 1:4, , i != 1L))
expect_equal(or3s(iyd %in% 1:4, , r != 9L),
bor3(iyd %in% 1:4, , r != 9L))
expect_equal(or3s(iye %in% 1:4, m %in% 1:4, ),
bor3(iye %in% 1:4, m %in% 1:4, ))
expect_equal(or3s(iyf %in% 1:4, t %in% 1:4, ),
bor3(iyf %in% 1:4, t %in% 1:4, ))
expect_equal(or3s(iyg %in% 1:4, u %in% 1:4, ),
bor3(iyg %in% 1:4, u %in% 1:4, ))
expect_equal(or3s(iyh %in% 1:4, k %in% 1:4, t != 0L),
bor3(iyh %in% 1:4, k %in% 1:4, t != 0L))
expect_equal(or3s(iyi %in% 1:4, a %in% 1:4, d != 1L),
bor3(iyi %in% 1:4, a %in% 1:4, d != 1L))
expect_equal(or3s(iyj %in% 1:4, l %in% 1:4, o != 9L),
bor3(iyj %in% 1:4, l %in% 1:4, o != 9L))
expect_equal(or3s(iyk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iyk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iyl %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iyl %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iym %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(iym %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(iyn %in% c(4L, -3L, 2L, 7L, 8L), , e %between% c(-1L, 1L)),
bor3(iyn %in% c(4L, -3L, 2L, 7L, 8L), , e %between% c(-1L, 1L)))
expect_equal(or3s(iyo %in% c(4L, -3L, 2L, 7L, 8L), , o %between% c(-1L, 1L)),
bor3(iyo %in% c(4L, -3L, 2L, 7L, 8L), , o %between% c(-1L, 1L)))
expect_equal(or3s(iyp %in% c(4L, -3L, 2L, 7L, 8L), , s %between% c(-1L, 1L)),
bor3(iyp %in% c(4L, -3L, 2L, 7L, 8L), , s %between% c(-1L, 1L)))
expect_equal(or3s(iyq %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(iyq %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(iyr %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(iyr %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(iys %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(iys %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(iyt %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L), b %between% c(-1L, 1L)),
bor3(iyt %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L), b %between% c(-1L, 1L)))
expect_equal(or3s(iyu %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)),
bor3(iyu %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)))
expect_equal(or3s(iyv %in% c(4L, -3L, 2L, 7L, 8L), w %in% c(4L, -3L, 2L, 7L, 8L), g %between% c(-1L, 1L)),
bor3(iyv %in% c(4L, -3L, 2L, 7L, 8L), w %in% c(4L, -3L, 2L, 7L, 8L), g %between% c(-1L, 1L)))
expect_equal(or3s(iyw %in% 1:4, , ),
bor3(iyw %in% 1:4, , ))
expect_equal(or3s(iyx %in% 1:4, , ),
bor3(iyx %in% 1:4, , ))
expect_equal(or3s(iyy %in% 1:4, , ),
bor3(iyy %in% 1:4, , ))
expect_equal(or3s(iyz %in% 1:4, , j %between% c(-1L, 1L)),
bor3(iyz %in% 1:4, , j %between% c(-1L, 1L)))
expect_equal(or3s(ja %in% 1:4, , f %between% c(-1L, 1L)),
bor3(ja %in% 1:4, , f %between% c(-1L, 1L)))
expect_equal(or3s(jb %in% 1:4, , z %between% c(-1L, 1L)),
bor3(jb %in% 1:4, , z %between% c(-1L, 1L)))
expect_equal(or3s(jc %in% 1:4, z %in% 1:4, ),
bor3(jc %in% 1:4, z %in% 1:4, ))
expect_equal(or3s(jd %in% 1:4, h %in% 1:4, ),
bor3(jd %in% 1:4, h %in% 1:4, ))
expect_equal(or3s(je %in% 1:4, e %in% 1:4, ),
bor3(je %in% 1:4, e %in% 1:4, ))
expect_equal(or3s(jf %in% 1:4, k %in% 1:4, c %between% c(-1L, 1L)),
bor3(jf %in% 1:4, k %in% 1:4, c %between% c(-1L, 1L)))
expect_equal(or3s(jg %in% 1:4, n %in% 1:4, l %between% c(-1L, 1L)),
bor3(jg %in% 1:4, n %in% 1:4, l %between% c(-1L, 1L)))
expect_equal(or3s(jh %in% 1:4, h %in% 1:4, o %between% c(-1L, 1L)),
bor3(jh %in% 1:4, h %in% 1:4, o %between% c(-1L, 1L)))
expect_equal(or3s(ji %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ji %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jl %in% c(4L, -3L, 2L, 7L, 8L), , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jl %in% c(4L, -3L, 2L, 7L, 8L), , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jm %in% c(4L, -3L, 2L, 7L, 8L), , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jm %in% c(4L, -3L, 2L, 7L, 8L), , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jn %in% c(4L, -3L, 2L, 7L, 8L), , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jn %in% c(4L, -3L, 2L, 7L, 8L), , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jo %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jo %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jp %in% c(4L, -3L, 2L, 7L, 8L), q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jp %in% c(4L, -3L, 2L, 7L, 8L), q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jq %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jq %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jr %in% c(4L, -3L, 2L, 7L, 8L), d %in% c(4L, -3L, 2L, 7L, 8L), r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jr %in% c(4L, -3L, 2L, 7L, 8L), d %in% c(4L, -3L, 2L, 7L, 8L), r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(js %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(js %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jt %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jt %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ju %in% 1:4, , ),
bor3(ju %in% 1:4, , ))
expect_equal(or3s(jv %in% 1:4, , ),
bor3(jv %in% 1:4, , ))
expect_equal(or3s(jw %in% 1:4, , ),
bor3(jw %in% 1:4, , ))
expect_equal(or3s(jx %in% 1:4, , b %in% 1:4),
bor3(jx %in% 1:4, , b %in% 1:4))
expect_equal(or3s(jy %in% 1:4, , f %in% 1:4),
bor3(jy %in% 1:4, , f %in% 1:4))
expect_equal(or3s(jz %in% 1:4, , h %in% 1:4),
bor3(jz %in% 1:4, , h %in% 1:4))
expect_equal(or3s(jaa %in% 1:4, a %in% 1:4, ),
bor3(jaa %in% 1:4, a %in% 1:4, ))
expect_equal(or3s(jab %in% 1:4, e %in% 1:4, ),
bor3(jab %in% 1:4, e %in% 1:4, ))
expect_equal(or3s(jac %in% 1:4, r %in% 1:4, ),
bor3(jac %in% 1:4, r %in% 1:4, ))
expect_equal(or3s(jad %in% 1:4, g %in% 1:4, h %in% 1:4),
bor3(jad %in% 1:4, g %in% 1:4, h %in% 1:4))
expect_equal(or3s(jae %in% 1:4, e %in% 1:4, k %in% 1:4),
bor3(jae %in% 1:4, e %in% 1:4, k %in% 1:4))
expect_equal(or3s(jaf %in% 1:4, n %in% 1:4, v %in% 1:4),
bor3(jaf %in% 1:4, n %in% 1:4, v %in% 1:4))
expect_equal(or3s(jag %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jag %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jah %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jah %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jai %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jai %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jaj %in% c(4L, -3L, 2L, 7L, 8L), , w < 0L),
bor3(jaj %in% c(4L, -3L, 2L, 7L, 8L), , w < 0L))
expect_equal(or3s(jak %in% c(4L, -3L, 2L, 7L, 8L), , r < 1L),
bor3(jak %in% c(4L, -3L, 2L, 7L, 8L), , r < 1L))
expect_equal(or3s(jal %in% c(4L, -3L, 2L, 7L, 8L), , p < 9L),
bor3(jal %in% c(4L, -3L, 2L, 7L, 8L), , p < 9L))
expect_equal(or3s(jam %in% c(4L, -3L, 2L, 7L, 8L), t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jam %in% c(4L, -3L, 2L, 7L, 8L), t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jan %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jan %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jao %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jao %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jap %in% c(4L, -3L, 2L, 7L, 8L), b %in% c(4L, -3L, 2L, 7L, 8L), j < 0L),
bor3(jap %in% c(4L, -3L, 2L, 7L, 8L), b %in% c(4L, -3L, 2L, 7L, 8L), j < 0L))
expect_equal(or3s(jaq %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), u < 1L),
bor3(jaq %in% c(4L, -3L, 2L, 7L, 8L), e %in% c(4L, -3L, 2L, 7L, 8L), u < 1L))
expect_equal(or3s(jar %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L), z < 9L),
bor3(jar %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L), z < 9L))
expect_equal(or3s(jas %in% 1:4, , ),
bor3(jas %in% 1:4, , ))
expect_equal(or3s(jat %in% 1:4, , ),
bor3(jat %in% 1:4, , ))
expect_equal(or3s(jau %in% 1:4, , ),
bor3(jau %in% 1:4, , ))
expect_equal(or3s(jav %in% 1:4, , h < 0L),
bor3(jav %in% 1:4, , h < 0L))
expect_equal(or3s(jaw %in% 1:4, , l < 1L),
bor3(jaw %in% 1:4, , l < 1L))
expect_equal(or3s(jax %in% 1:4, , n < 9L),
bor3(jax %in% 1:4, , n < 9L))
expect_equal(or3s(jay %in% 1:4, m %in% 1:4, ),
bor3(jay %in% 1:4, m %in% 1:4, ))
expect_equal(or3s(jaz %in% 1:4, a %in% 1:4, ),
bor3(jaz %in% 1:4, a %in% 1:4, ))
expect_equal(or3s(jba %in% 1:4, p %in% 1:4, ),
bor3(jba %in% 1:4, p %in% 1:4, ))
expect_equal(or3s(jbb %in% 1:4, c %in% 1:4, w < 0L),
bor3(jbb %in% 1:4, c %in% 1:4, w < 0L))
expect_equal(or3s(jbc %in% 1:4, v %in% 1:4, l < 1L),
bor3(jbc %in% 1:4, v %in% 1:4, l < 1L))
expect_equal(or3s(jbd %in% 1:4, i %in% 1:4, a < 9L),
bor3(jbd %in% 1:4, i %in% 1:4, a < 9L))
expect_equal(or3s(jbe %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jbe %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jbf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jbf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jbg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jbg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jbh %in% c(4L, -3L, 2L, 7L, 8L), , d <= 0L),
bor3(jbh %in% c(4L, -3L, 2L, 7L, 8L), , d <= 0L))
expect_equal(or3s(jbi %in% c(4L, -3L, 2L, 7L, 8L), , i <= 1L),
bor3(jbi %in% c(4L, -3L, 2L, 7L, 8L), , i <= 1L))
expect_equal(or3s(jbj %in% c(4L, -3L, 2L, 7L, 8L), , n <= 9L),
bor3(jbj %in% c(4L, -3L, 2L, 7L, 8L), , n <= 9L))
expect_equal(or3s(jbk %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jbk %in% c(4L, -3L, 2L, 7L, 8L), x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jbl %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jbl %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jbm %in% c(4L, -3L, 2L, 7L, 8L), q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jbm %in% c(4L, -3L, 2L, 7L, 8L), q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jbn %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), e <= 0L),
bor3(jbn %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), e <= 0L))
expect_equal(or3s(jbo %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), x <= 1L),
bor3(jbo %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L), x <= 1L))
expect_equal(or3s(jbp %in% c(4L, -3L, 2L, 7L, 8L), k %in% c(4L, -3L, 2L, 7L, 8L), a <= 9L),
bor3(jbp %in% c(4L, -3L, 2L, 7L, 8L), k %in% c(4L, -3L, 2L, 7L, 8L), a <= 9L))
expect_equal(or3s(jbq %in% 1:4, , ),
bor3(jbq %in% 1:4, , ))
expect_equal(or3s(jbr %in% 1:4, , ),
bor3(jbr %in% 1:4, , ))
expect_equal(or3s(jbs %in% 1:4, , ),
bor3(jbs %in% 1:4, , ))
expect_equal(or3s(jbt %in% 1:4, , k <= 0L),
bor3(jbt %in% 1:4, , k <= 0L))
expect_equal(or3s(jbu %in% 1:4, , w <= 1L),
bor3(jbu %in% 1:4, , w <= 1L))
expect_equal(or3s(jbv %in% 1:4, , f <= 9L),
bor3(jbv %in% 1:4, , f <= 9L))
expect_equal(or3s(jbw %in% 1:4, x %in% 1:4, ),
bor3(jbw %in% 1:4, x %in% 1:4, ))
expect_equal(or3s(jbx %in% 1:4, k %in% 1:4, ),
bor3(jbx %in% 1:4, k %in% 1:4, ))
expect_equal(or3s(jby %in% 1:4, n %in% 1:4, ),
bor3(jby %in% 1:4, n %in% 1:4, ))
expect_equal(or3s(jbz %in% 1:4, x %in% 1:4, f <= 0L),
bor3(jbz %in% 1:4, x %in% 1:4, f <= 0L))
expect_equal(or3s(jca %in% 1:4, r %in% 1:4, h <= 1L),
bor3(jca %in% 1:4, r %in% 1:4, h <= 1L))
expect_equal(or3s(jcb %in% 1:4, o %in% 1:4, c <= 9L),
bor3(jcb %in% 1:4, o %in% 1:4, c <= 9L))
expect_equal(or3s(jcc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jcc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jcd %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jcd %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jce %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jce %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jcf %in% c(4L, -3L, 2L, 7L, 8L), , z == 0L),
bor3(jcf %in% c(4L, -3L, 2L, 7L, 8L), , z == 0L))
expect_equal(or3s(jcg %in% c(4L, -3L, 2L, 7L, 8L), , o == 1L),
bor3(jcg %in% c(4L, -3L, 2L, 7L, 8L), , o == 1L))
expect_equal(or3s(jch %in% c(4L, -3L, 2L, 7L, 8L), , f == 9L),
bor3(jch %in% c(4L, -3L, 2L, 7L, 8L), , f == 9L))
expect_equal(or3s(jci %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jci %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jcj %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jcj %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jck %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jck %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jcl %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L), s == 0L),
bor3(jcl %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L), s == 0L))
expect_equal(or3s(jcm %in% c(4L, -3L, 2L, 7L, 8L), h %in% c(4L, -3L, 2L, 7L, 8L), l == 1L),
bor3(jcm %in% c(4L, -3L, 2L, 7L, 8L), h %in% c(4L, -3L, 2L, 7L, 8L), l == 1L))
expect_equal(or3s(jcn %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), r == 9L),
bor3(jcn %in% c(4L, -3L, 2L, 7L, 8L), f %in% c(4L, -3L, 2L, 7L, 8L), r == 9L))
expect_equal(or3s(jco %in% 1:4, , ),
bor3(jco %in% 1:4, , ))
expect_equal(or3s(jcp %in% 1:4, , ),
bor3(jcp %in% 1:4, , ))
expect_equal(or3s(jcq %in% 1:4, , ),
bor3(jcq %in% 1:4, , ))
expect_equal(or3s(jcr %in% 1:4, , n == 0L),
bor3(jcr %in% 1:4, , n == 0L))
expect_equal(or3s(jcs %in% 1:4, , g == 1L),
bor3(jcs %in% 1:4, , g == 1L))
expect_equal(or3s(jct %in% 1:4, , r == 9L),
bor3(jct %in% 1:4, , r == 9L))
expect_equal(or3s(jcu %in% 1:4, m %in% 1:4, ),
bor3(jcu %in% 1:4, m %in% 1:4, ))
expect_equal(or3s(jcv %in% 1:4, h %in% 1:4, ),
bor3(jcv %in% 1:4, h %in% 1:4, ))
expect_equal(or3s(jcw %in% 1:4, f %in% 1:4, ),
bor3(jcw %in% 1:4, f %in% 1:4, ))
expect_equal(or3s(jcx %in% 1:4, c %in% 1:4, l == 0L),
bor3(jcx %in% 1:4, c %in% 1:4, l == 0L))
expect_equal(or3s(jcy %in% 1:4, s %in% 1:4, e == 1L),
bor3(jcy %in% 1:4, s %in% 1:4, e == 1L))
expect_equal(or3s(jcz %in% 1:4, f %in% 1:4, p == 9L),
bor3(jcz %in% 1:4, f %in% 1:4, p == 9L))
expect_equal(or3s(jda %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jda %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jdb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jdb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jdc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jdc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jdd %in% c(4L, -3L, 2L, 7L, 8L), , x > 0L),
bor3(jdd %in% c(4L, -3L, 2L, 7L, 8L), , x > 0L))
expect_equal(or3s(jde %in% c(4L, -3L, 2L, 7L, 8L), , g > 1L),
bor3(jde %in% c(4L, -3L, 2L, 7L, 8L), , g > 1L))
expect_equal(or3s(jdf %in% c(4L, -3L, 2L, 7L, 8L), , u > 9L),
bor3(jdf %in% c(4L, -3L, 2L, 7L, 8L), , u > 9L))
expect_equal(or3s(jdg %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jdg %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jdh %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jdh %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jdi %in% c(4L, -3L, 2L, 7L, 8L), k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jdi %in% c(4L, -3L, 2L, 7L, 8L), k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jdj %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), x > 0L),
bor3(jdj %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), x > 0L))
expect_equal(or3s(jdk %in% c(4L, -3L, 2L, 7L, 8L), z %in% c(4L, -3L, 2L, 7L, 8L), m > 1L),
bor3(jdk %in% c(4L, -3L, 2L, 7L, 8L), z %in% c(4L, -3L, 2L, 7L, 8L), m > 1L))
expect_equal(or3s(jdl %in% c(4L, -3L, 2L, 7L, 8L), z %in% c(4L, -3L, 2L, 7L, 8L), o > 9L),
bor3(jdl %in% c(4L, -3L, 2L, 7L, 8L), z %in% c(4L, -3L, 2L, 7L, 8L), o > 9L))
expect_equal(or3s(jdm %in% 1:4, , ),
bor3(jdm %in% 1:4, , ))
expect_equal(or3s(jdn %in% 1:4, , ),
bor3(jdn %in% 1:4, , ))
expect_equal(or3s(jdo %in% 1:4, , ),
bor3(jdo %in% 1:4, , ))
expect_equal(or3s(jdp %in% 1:4, , n > 0L),
bor3(jdp %in% 1:4, , n > 0L))
expect_equal(or3s(jdq %in% 1:4, , k > 1L),
bor3(jdq %in% 1:4, , k > 1L))
expect_equal(or3s(jdr %in% 1:4, , c > 9L),
bor3(jdr %in% 1:4, , c > 9L))
expect_equal(or3s(jds %in% 1:4, p %in% 1:4, ),
bor3(jds %in% 1:4, p %in% 1:4, ))
expect_equal(or3s(jdt %in% 1:4, b %in% 1:4, ),
bor3(jdt %in% 1:4, b %in% 1:4, ))
expect_equal(or3s(jdu %in% 1:4, n %in% 1:4, ),
bor3(jdu %in% 1:4, n %in% 1:4, ))
expect_equal(or3s(jdv %in% 1:4, t %in% 1:4, d > 0L),
bor3(jdv %in% 1:4, t %in% 1:4, d > 0L))
expect_equal(or3s(jdw %in% 1:4, h %in% 1:4, r > 1L),
bor3(jdw %in% 1:4, h %in% 1:4, r > 1L))
expect_equal(or3s(jdx %in% 1:4, u %in% 1:4, t > 9L),
bor3(jdx %in% 1:4, u %in% 1:4, t > 9L))
expect_equal(or3s(jdy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jdy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jdz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jdz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jea %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jea %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jeb %in% c(4L, -3L, 2L, 7L, 8L), , d >= 0L),
bor3(jeb %in% c(4L, -3L, 2L, 7L, 8L), , d >= 0L))
expect_equal(or3s(jec %in% c(4L, -3L, 2L, 7L, 8L), , i >= 1L),
bor3(jec %in% c(4L, -3L, 2L, 7L, 8L), , i >= 1L))
expect_equal(or3s(jed %in% c(4L, -3L, 2L, 7L, 8L), , x >= 9L),
bor3(jed %in% c(4L, -3L, 2L, 7L, 8L), , x >= 9L))
expect_equal(or3s(jee %in% c(4L, -3L, 2L, 7L, 8L), w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jee %in% c(4L, -3L, 2L, 7L, 8L), w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jef %in% c(4L, -3L, 2L, 7L, 8L), d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jef %in% c(4L, -3L, 2L, 7L, 8L), d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jeg %in% c(4L, -3L, 2L, 7L, 8L), q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(jeg %in% c(4L, -3L, 2L, 7L, 8L), q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(jeh %in% c(4L, -3L, 2L, 7L, 8L), o %in% c(4L, -3L, 2L, 7L, 8L), p >= 0L),
bor3(jeh %in% c(4L, -3L, 2L, 7L, 8L), o %in% c(4L, -3L, 2L, 7L, 8L), p >= 0L))
expect_equal(or3s(jei %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), b >= 1L),
bor3(jei %in% c(4L, -3L, 2L, 7L, 8L), i %in% c(4L, -3L, 2L, 7L, 8L), b >= 1L))
expect_equal(or3s(jej %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L),
bor3(jej %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L))
expect_equal(or3s(jek %in% 1:4, , ),
bor3(jek %in% 1:4, , ))
expect_equal(or3s(jel %in% 1:4, , ),
bor3(jel %in% 1:4, , ))
expect_equal(or3s(jem %in% 1:4, , ),
bor3(jem %in% 1:4, , ))
expect_equal(or3s(jen %in% 1:4, , c >= 0L),
bor3(jen %in% 1:4, , c >= 0L))
expect_equal(or3s(jeo %in% 1:4, , f >= 1L),
bor3(jeo %in% 1:4, , f >= 1L))
expect_equal(or3s(jep %in% 1:4, , r >= 9L),
bor3(jep %in% 1:4, , r >= 9L))
expect_equal(or3s(jeq %in% 1:4, l %in% 1:4, ),
bor3(jeq %in% 1:4, l %in% 1:4, ))
expect_equal(or3s(jer %in% 1:4, l %in% 1:4, ),
bor3(jer %in% 1:4, l %in% 1:4, ))
expect_equal(or3s(jes %in% 1:4, f %in% 1:4, ),
bor3(jes %in% 1:4, f %in% 1:4, ))
expect_equal(or3s(jet %in% 1:4, x %in% 1:4, l >= 0L),
bor3(jet %in% 1:4, x %in% 1:4, l >= 0L))
expect_equal(or3s(jeu %in% 1:4, r %in% 1:4, k >= 1L),
bor3(jeu %in% 1:4, r %in% 1:4, k >= 1L))
expect_equal(or3s(jev %in% 1:4, i %in% 1:4, f >= 9L),
bor3(jev %in% 1:4, i %in% 1:4, f >= 9L))
expect_equal(or3s(jew %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jew %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jex %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jex %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jey %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jey %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jez %in% c(4L, -3L, 2L, 7L, 8L), , logi_x),
bor3(jez %in% c(4L, -3L, 2L, 7L, 8L), , logi_x))
expect_equal(or3s(jfa %in% c(4L, -3L, 2L, 7L, 8L), , logi_t),
bor3(jfa %in% c(4L, -3L, 2L, 7L, 8L), , logi_t))
expect_equal(or3s(jfb %in% c(4L, -3L, 2L, 7L, 8L), , logi_j),
bor3(jfb %in% c(4L, -3L, 2L, 7L, 8L), , logi_j))
expect_equal(or3s(jfc %in% c(4L, -3L, 2L, 7L, 8L), a < 0L, ),
bor3(jfc %in% c(4L, -3L, 2L, 7L, 8L), a < 0L, ))
expect_equal(or3s(jfd %in% c(4L, -3L, 2L, 7L, 8L), g < 1L, ),
bor3(jfd %in% c(4L, -3L, 2L, 7L, 8L), g < 1L, ))
expect_equal(or3s(jfe %in% c(4L, -3L, 2L, 7L, 8L), q < 9L, ),
bor3(jfe %in% c(4L, -3L, 2L, 7L, 8L), q < 9L, ))
expect_equal(or3s(jff %in% c(4L, -3L, 2L, 7L, 8L), q < 0L, logi_b),
bor3(jff %in% c(4L, -3L, 2L, 7L, 8L), q < 0L, logi_b))
expect_equal(or3s(jfg %in% c(4L, -3L, 2L, 7L, 8L), p < 1L, logi_z),
bor3(jfg %in% c(4L, -3L, 2L, 7L, 8L), p < 1L, logi_z))
expect_equal(or3s(jfh %in% c(4L, -3L, 2L, 7L, 8L), o < 9L, logi_a),
bor3(jfh %in% c(4L, -3L, 2L, 7L, 8L), o < 9L, logi_a))
expect_equal(or3s(jfi %in% 1:4, , ),
bor3(jfi %in% 1:4, , ))
expect_equal(or3s(jfj %in% 1:4, , ),
bor3(jfj %in% 1:4, , ))
expect_equal(or3s(jfk %in% 1:4, , ),
bor3(jfk %in% 1:4, , ))
expect_equal(or3s(jfl %in% 1:4, , logi_p),
bor3(jfl %in% 1:4, , logi_p))
expect_equal(or3s(jfm %in% 1:4, , logi_u),
bor3(jfm %in% 1:4, , logi_u))
expect_equal(or3s(jfn %in% 1:4, , logi_n),
bor3(jfn %in% 1:4, , logi_n))
expect_equal(or3s(jfo %in% 1:4, g < 0L, ),
bor3(jfo %in% 1:4, g < 0L, ))
expect_equal(or3s(jfp %in% 1:4, s < 1L, ),
bor3(jfp %in% 1:4, s < 1L, ))
expect_equal(or3s(jfq %in% 1:4, j < 9L, ),
bor3(jfq %in% 1:4, j < 9L, ))
expect_equal(or3s(jfr %in% 1:4, a < 0L, logi_m),
bor3(jfr %in% 1:4, a < 0L, logi_m))
expect_equal(or3s(jfs %in% 1:4, z < 1L, logi_j),
bor3(jfs %in% 1:4, z < 1L, logi_j))
expect_equal(or3s(jft %in% 1:4, m < 9L, logi_n),
bor3(jft %in% 1:4, m < 9L, logi_n))
expect_equal(or3s(jfu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jfu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jfv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jfv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jfw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jfw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jfx %in% c(4L, -3L, 2L, 7L, 8L), , !logi_z),
bor3(jfx %in% c(4L, -3L, 2L, 7L, 8L), , !logi_z))
expect_equal(or3s(jfy %in% c(4L, -3L, 2L, 7L, 8L), , !logi_o),
bor3(jfy %in% c(4L, -3L, 2L, 7L, 8L), , !logi_o))
expect_equal(or3s(jfz %in% c(4L, -3L, 2L, 7L, 8L), , !logi_h),
bor3(jfz %in% c(4L, -3L, 2L, 7L, 8L), , !logi_h))
expect_equal(or3s(jga %in% c(4L, -3L, 2L, 7L, 8L), v < 0L, ),
bor3(jga %in% c(4L, -3L, 2L, 7L, 8L), v < 0L, ))
expect_equal(or3s(jgb %in% c(4L, -3L, 2L, 7L, 8L), o < 1L, ),
bor3(jgb %in% c(4L, -3L, 2L, 7L, 8L), o < 1L, ))
expect_equal(or3s(jgc %in% c(4L, -3L, 2L, 7L, 8L), d < 9L, ),
bor3(jgc %in% c(4L, -3L, 2L, 7L, 8L), d < 9L, ))
expect_equal(or3s(jgd %in% c(4L, -3L, 2L, 7L, 8L), p < 0L, !logi_v),
bor3(jgd %in% c(4L, -3L, 2L, 7L, 8L), p < 0L, !logi_v))
expect_equal(or3s(jge %in% c(4L, -3L, 2L, 7L, 8L), c < 1L, !logi_t),
bor3(jge %in% c(4L, -3L, 2L, 7L, 8L), c < 1L, !logi_t))
expect_equal(or3s(jgf %in% c(4L, -3L, 2L, 7L, 8L), q < 9L, !logi_q),
bor3(jgf %in% c(4L, -3L, 2L, 7L, 8L), q < 9L, !logi_q))
expect_equal(or3s(jgg %in% 1:4, , ),
bor3(jgg %in% 1:4, , ))
expect_equal(or3s(jgh %in% 1:4, , ),
bor3(jgh %in% 1:4, , ))
expect_equal(or3s(jgi %in% 1:4, , ),
bor3(jgi %in% 1:4, , ))
expect_equal(or3s(jgj %in% 1:4, , !logi_y),
bor3(jgj %in% 1:4, , !logi_y))
expect_equal(or3s(jgk %in% 1:4, , !logi_m),
bor3(jgk %in% 1:4, , !logi_m))
expect_equal(or3s(jgl %in% 1:4, , !logi_c),
bor3(jgl %in% 1:4, , !logi_c))
expect_equal(or3s(jgm %in% 1:4, s < 0L, ),
bor3(jgm %in% 1:4, s < 0L, ))
expect_equal(or3s(jgn %in% 1:4, a < 1L, ),
bor3(jgn %in% 1:4, a < 1L, ))
expect_equal(or3s(jgo %in% 1:4, k < 9L, ),
bor3(jgo %in% 1:4, k < 9L, ))
expect_equal(or3s(jgp %in% 1:4, g < 0L, !logi_s),
bor3(jgp %in% 1:4, g < 0L, !logi_s))
expect_equal(or3s(jgq %in% 1:4, z < 1L, !logi_t),
bor3(jgq %in% 1:4, z < 1L, !logi_t))
expect_equal(or3s(jgr %in% 1:4, w < 9L, !logi_k),
bor3(jgr %in% 1:4, w < 9L, !logi_k))
expect_equal(or3s(jgs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jgs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jgt %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jgt %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jgu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jgu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jgv %in% c(4L, -3L, 2L, 7L, 8L), , g != 0L),
bor3(jgv %in% c(4L, -3L, 2L, 7L, 8L), , g != 0L))
expect_equal(or3s(jgw %in% c(4L, -3L, 2L, 7L, 8L), , u != 1L),
bor3(jgw %in% c(4L, -3L, 2L, 7L, 8L), , u != 1L))
expect_equal(or3s(jgx %in% c(4L, -3L, 2L, 7L, 8L), , u != 9L),
bor3(jgx %in% c(4L, -3L, 2L, 7L, 8L), , u != 9L))
expect_equal(or3s(jgy %in% c(4L, -3L, 2L, 7L, 8L), y < 0L, ),
bor3(jgy %in% c(4L, -3L, 2L, 7L, 8L), y < 0L, ))
expect_equal(or3s(jgz %in% c(4L, -3L, 2L, 7L, 8L), b < 1L, ),
bor3(jgz %in% c(4L, -3L, 2L, 7L, 8L), b < 1L, ))
expect_equal(or3s(jha %in% c(4L, -3L, 2L, 7L, 8L), f < 9L, ),
bor3(jha %in% c(4L, -3L, 2L, 7L, 8L), f < 9L, ))
expect_equal(or3s(jhb %in% c(4L, -3L, 2L, 7L, 8L), y < 0L, o != 0L),
bor3(jhb %in% c(4L, -3L, 2L, 7L, 8L), y < 0L, o != 0L))
expect_equal(or3s(jhc %in% c(4L, -3L, 2L, 7L, 8L), r < 1L, z != 1L),
bor3(jhc %in% c(4L, -3L, 2L, 7L, 8L), r < 1L, z != 1L))
expect_equal(or3s(jhd %in% c(4L, -3L, 2L, 7L, 8L), d < 9L, p != 9L),
bor3(jhd %in% c(4L, -3L, 2L, 7L, 8L), d < 9L, p != 9L))
expect_equal(or3s(jhe %in% 1:4, , ),
bor3(jhe %in% 1:4, , ))
expect_equal(or3s(jhf %in% 1:4, , ),
bor3(jhf %in% 1:4, , ))
expect_equal(or3s(jhg %in% 1:4, , ),
bor3(jhg %in% 1:4, , ))
expect_equal(or3s(jhh %in% 1:4, , p != 0L),
bor3(jhh %in% 1:4, , p != 0L))
expect_equal(or3s(jhi %in% 1:4, , o != 1L),
bor3(jhi %in% 1:4, , o != 1L))
expect_equal(or3s(jhj %in% 1:4, , s != 9L),
bor3(jhj %in% 1:4, , s != 9L))
expect_equal(or3s(jhk %in% 1:4, f < 0L, ),
bor3(jhk %in% 1:4, f < 0L, ))
expect_equal(or3s(jhl %in% 1:4, h < 1L, ),
bor3(jhl %in% 1:4, h < 1L, ))
expect_equal(or3s(jhm %in% 1:4, l < 9L, ),
bor3(jhm %in% 1:4, l < 9L, ))
expect_equal(or3s(jhn %in% 1:4, o < 0L, i != 0L),
bor3(jhn %in% 1:4, o < 0L, i != 0L))
expect_equal(or3s(jho %in% 1:4, p < 1L, x != 1L),
bor3(jho %in% 1:4, p < 1L, x != 1L))
expect_equal(or3s(jhp %in% 1:4, p < 9L, e != 9L),
bor3(jhp %in% 1:4, p < 9L, e != 9L))
expect_equal(or3s(jhq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jhq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jhr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jhr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jhs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jhs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jht %in% c(4L, -3L, 2L, 7L, 8L), , i %between% c(-1L, 1L)),
bor3(jht %in% c(4L, -3L, 2L, 7L, 8L), , i %between% c(-1L, 1L)))
expect_equal(or3s(jhu %in% c(4L, -3L, 2L, 7L, 8L), , s %between% c(-1L, 1L)),
bor3(jhu %in% c(4L, -3L, 2L, 7L, 8L), , s %between% c(-1L, 1L)))
expect_equal(or3s(jhv %in% c(4L, -3L, 2L, 7L, 8L), , m %between% c(-1L, 1L)),
bor3(jhv %in% c(4L, -3L, 2L, 7L, 8L), , m %between% c(-1L, 1L)))
expect_equal(or3s(jhw %in% c(4L, -3L, 2L, 7L, 8L), f < 0L, ),
bor3(jhw %in% c(4L, -3L, 2L, 7L, 8L), f < 0L, ))
expect_equal(or3s(jhx %in% c(4L, -3L, 2L, 7L, 8L), l < 1L, ),
bor3(jhx %in% c(4L, -3L, 2L, 7L, 8L), l < 1L, ))
expect_equal(or3s(jhy %in% c(4L, -3L, 2L, 7L, 8L), w < 9L, ),
bor3(jhy %in% c(4L, -3L, 2L, 7L, 8L), w < 9L, ))
expect_equal(or3s(jhz %in% c(4L, -3L, 2L, 7L, 8L), p < 0L, n %between% c(-1L, 1L)),
bor3(jhz %in% c(4L, -3L, 2L, 7L, 8L), p < 0L, n %between% c(-1L, 1L)))
expect_equal(or3s(jia %in% c(4L, -3L, 2L, 7L, 8L), s < 1L, y %between% c(-1L, 1L)),
bor3(jia %in% c(4L, -3L, 2L, 7L, 8L), s < 1L, y %between% c(-1L, 1L)))
expect_equal(or3s(jib %in% c(4L, -3L, 2L, 7L, 8L), k < 9L, y %between% c(-1L, 1L)),
bor3(jib %in% c(4L, -3L, 2L, 7L, 8L), k < 9L, y %between% c(-1L, 1L)))
expect_equal(or3s(jic %in% 1:4, , ),
bor3(jic %in% 1:4, , ))
expect_equal(or3s(jid %in% 1:4, , ),
bor3(jid %in% 1:4, , ))
expect_equal(or3s(jie %in% 1:4, , ),
bor3(jie %in% 1:4, , ))
expect_equal(or3s(jif %in% 1:4, , e %between% c(-1L, 1L)),
bor3(jif %in% 1:4, , e %between% c(-1L, 1L)))
expect_equal(or3s(jig %in% 1:4, , l %between% c(-1L, 1L)),
bor3(jig %in% 1:4, , l %between% c(-1L, 1L)))
expect_equal(or3s(jih %in% 1:4, , b %between% c(-1L, 1L)),
bor3(jih %in% 1:4, , b %between% c(-1L, 1L)))
expect_equal(or3s(jii %in% 1:4, c < 0L, ),
bor3(jii %in% 1:4, c < 0L, ))
expect_equal(or3s(jij %in% 1:4, y < 1L, ),
bor3(jij %in% 1:4, y < 1L, ))
expect_equal(or3s(jik %in% 1:4, e < 9L, ),
bor3(jik %in% 1:4, e < 9L, ))
expect_equal(or3s(jil %in% 1:4, a < 0L, x %between% c(-1L, 1L)),
bor3(jil %in% 1:4, a < 0L, x %between% c(-1L, 1L)))
expect_equal(or3s(jim %in% 1:4, x < 1L, d %between% c(-1L, 1L)),
bor3(jim %in% 1:4, x < 1L, d %between% c(-1L, 1L)))
expect_equal(or3s(jin %in% 1:4, x < 9L, h %between% c(-1L, 1L)),
bor3(jin %in% 1:4, x < 9L, h %between% c(-1L, 1L)))
expect_equal(or3s(jio %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jio %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jip %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jip %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jiq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jiq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jir %in% c(4L, -3L, 2L, 7L, 8L), , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jir %in% c(4L, -3L, 2L, 7L, 8L), , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jis %in% c(4L, -3L, 2L, 7L, 8L), , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jis %in% c(4L, -3L, 2L, 7L, 8L), , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jit %in% c(4L, -3L, 2L, 7L, 8L), , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jit %in% c(4L, -3L, 2L, 7L, 8L), , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jiu %in% c(4L, -3L, 2L, 7L, 8L), k < 0L, ),
bor3(jiu %in% c(4L, -3L, 2L, 7L, 8L), k < 0L, ))
expect_equal(or3s(jiv %in% c(4L, -3L, 2L, 7L, 8L), a < 1L, ),
bor3(jiv %in% c(4L, -3L, 2L, 7L, 8L), a < 1L, ))
expect_equal(or3s(jiw %in% c(4L, -3L, 2L, 7L, 8L), c < 9L, ),
bor3(jiw %in% c(4L, -3L, 2L, 7L, 8L), c < 9L, ))
expect_equal(or3s(jix %in% c(4L, -3L, 2L, 7L, 8L), d < 0L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jix %in% c(4L, -3L, 2L, 7L, 8L), d < 0L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jiy %in% c(4L, -3L, 2L, 7L, 8L), f < 1L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jiy %in% c(4L, -3L, 2L, 7L, 8L), f < 1L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jiz %in% c(4L, -3L, 2L, 7L, 8L), e < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jiz %in% c(4L, -3L, 2L, 7L, 8L), e < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jja %in% 1:4, , ),
bor3(jja %in% 1:4, , ))
expect_equal(or3s(jjb %in% 1:4, , ),
bor3(jjb %in% 1:4, , ))
expect_equal(or3s(jjc %in% 1:4, , ),
bor3(jjc %in% 1:4, , ))
expect_equal(or3s(jjd %in% 1:4, , a %in% 1:4),
bor3(jjd %in% 1:4, , a %in% 1:4))
expect_equal(or3s(jje %in% 1:4, , y %in% 1:4),
bor3(jje %in% 1:4, , y %in% 1:4))
expect_equal(or3s(jjf %in% 1:4, , c %in% 1:4),
bor3(jjf %in% 1:4, , c %in% 1:4))
expect_equal(or3s(jjg %in% 1:4, h < 0L, ),
bor3(jjg %in% 1:4, h < 0L, ))
expect_equal(or3s(jjh %in% 1:4, y < 1L, ),
bor3(jjh %in% 1:4, y < 1L, ))
expect_equal(or3s(jji %in% 1:4, e < 9L, ),
bor3(jji %in% 1:4, e < 9L, ))
expect_equal(or3s(jjj %in% 1:4, u < 0L, e %in% 1:4),
bor3(jjj %in% 1:4, u < 0L, e %in% 1:4))
expect_equal(or3s(jjk %in% 1:4, e < 1L, m %in% 1:4),
bor3(jjk %in% 1:4, e < 1L, m %in% 1:4))
expect_equal(or3s(jjl %in% 1:4, b < 9L, p %in% 1:4),
bor3(jjl %in% 1:4, b < 9L, p %in% 1:4))
expect_equal(or3s(jjm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jjm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jjn %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jjn %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jjo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jjo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jjp %in% c(4L, -3L, 2L, 7L, 8L), , q < 0L),
bor3(jjp %in% c(4L, -3L, 2L, 7L, 8L), , q < 0L))
expect_equal(or3s(jjq %in% c(4L, -3L, 2L, 7L, 8L), , x < 1L),
bor3(jjq %in% c(4L, -3L, 2L, 7L, 8L), , x < 1L))
expect_equal(or3s(jjr %in% c(4L, -3L, 2L, 7L, 8L), , n < 9L),
bor3(jjr %in% c(4L, -3L, 2L, 7L, 8L), , n < 9L))
expect_equal(or3s(jjs %in% c(4L, -3L, 2L, 7L, 8L), j < 0L, ),
bor3(jjs %in% c(4L, -3L, 2L, 7L, 8L), j < 0L, ))
expect_equal(or3s(jjt %in% c(4L, -3L, 2L, 7L, 8L), x < 1L, ),
bor3(jjt %in% c(4L, -3L, 2L, 7L, 8L), x < 1L, ))
expect_equal(or3s(jju %in% c(4L, -3L, 2L, 7L, 8L), b < 9L, ),
bor3(jju %in% c(4L, -3L, 2L, 7L, 8L), b < 9L, ))
expect_equal(or3s(jjv %in% c(4L, -3L, 2L, 7L, 8L), a < 0L, q < 0L),
bor3(jjv %in% c(4L, -3L, 2L, 7L, 8L), a < 0L, q < 0L))
expect_equal(or3s(jjw %in% c(4L, -3L, 2L, 7L, 8L), f < 1L, s < 1L),
bor3(jjw %in% c(4L, -3L, 2L, 7L, 8L), f < 1L, s < 1L))
expect_equal(or3s(jjx %in% c(4L, -3L, 2L, 7L, 8L), s < 9L, n < 9L),
bor3(jjx %in% c(4L, -3L, 2L, 7L, 8L), s < 9L, n < 9L))
expect_equal(or3s(jjy %in% 1:4, , ),
bor3(jjy %in% 1:4, , ))
expect_equal(or3s(jjz %in% 1:4, , ),
bor3(jjz %in% 1:4, , ))
expect_equal(or3s(jka %in% 1:4, , ),
bor3(jka %in% 1:4, , ))
expect_equal(or3s(jkb %in% 1:4, , y < 0L),
bor3(jkb %in% 1:4, , y < 0L))
expect_equal(or3s(jkc %in% 1:4, , u < 1L),
bor3(jkc %in% 1:4, , u < 1L))
expect_equal(or3s(jkd %in% 1:4, , l < 9L),
bor3(jkd %in% 1:4, , l < 9L))
expect_equal(or3s(jke %in% 1:4, j < 0L, ),
bor3(jke %in% 1:4, j < 0L, ))
expect_equal(or3s(jkf %in% 1:4, r < 1L, ),
bor3(jkf %in% 1:4, r < 1L, ))
expect_equal(or3s(jkg %in% 1:4, n < 9L, ),
bor3(jkg %in% 1:4, n < 9L, ))
expect_equal(or3s(jkh %in% 1:4, p < 0L, k < 0L),
bor3(jkh %in% 1:4, p < 0L, k < 0L))
expect_equal(or3s(jki %in% 1:4, q < 1L, t < 1L),
bor3(jki %in% 1:4, q < 1L, t < 1L))
expect_equal(or3s(jkj %in% 1:4, u < 9L, u < 9L),
bor3(jkj %in% 1:4, u < 9L, u < 9L))
expect_equal(or3s(jkk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jkk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jkl %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jkl %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jkm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jkm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jkn %in% c(4L, -3L, 2L, 7L, 8L), , w <= 0L),
bor3(jkn %in% c(4L, -3L, 2L, 7L, 8L), , w <= 0L))
expect_equal(or3s(jko %in% c(4L, -3L, 2L, 7L, 8L), , j <= 1L),
bor3(jko %in% c(4L, -3L, 2L, 7L, 8L), , j <= 1L))
expect_equal(or3s(jkp %in% c(4L, -3L, 2L, 7L, 8L), , e <= 9L),
bor3(jkp %in% c(4L, -3L, 2L, 7L, 8L), , e <= 9L))
expect_equal(or3s(jkq %in% c(4L, -3L, 2L, 7L, 8L), s < 0L, ),
bor3(jkq %in% c(4L, -3L, 2L, 7L, 8L), s < 0L, ))
expect_equal(or3s(jkr %in% c(4L, -3L, 2L, 7L, 8L), k < 1L, ),
bor3(jkr %in% c(4L, -3L, 2L, 7L, 8L), k < 1L, ))
expect_equal(or3s(jks %in% c(4L, -3L, 2L, 7L, 8L), v < 9L, ),
bor3(jks %in% c(4L, -3L, 2L, 7L, 8L), v < 9L, ))
expect_equal(or3s(jkt %in% c(4L, -3L, 2L, 7L, 8L), x < 0L, t <= 0L),
bor3(jkt %in% c(4L, -3L, 2L, 7L, 8L), x < 0L, t <= 0L))
expect_equal(or3s(jku %in% c(4L, -3L, 2L, 7L, 8L), y < 1L, z <= 1L),
bor3(jku %in% c(4L, -3L, 2L, 7L, 8L), y < 1L, z <= 1L))
expect_equal(or3s(jkv %in% c(4L, -3L, 2L, 7L, 8L), r < 9L, h <= 9L),
bor3(jkv %in% c(4L, -3L, 2L, 7L, 8L), r < 9L, h <= 9L))
expect_equal(or3s(jkw %in% 1:4, , ),
bor3(jkw %in% 1:4, , ))
expect_equal(or3s(jkx %in% 1:4, , ),
bor3(jkx %in% 1:4, , ))
expect_equal(or3s(jky %in% 1:4, , ),
bor3(jky %in% 1:4, , ))
expect_equal(or3s(jkz %in% 1:4, , h <= 0L),
bor3(jkz %in% 1:4, , h <= 0L))
expect_equal(or3s(jla %in% 1:4, , y <= 1L),
bor3(jla %in% 1:4, , y <= 1L))
expect_equal(or3s(jlb %in% 1:4, , y <= 9L),
bor3(jlb %in% 1:4, , y <= 9L))
expect_equal(or3s(jlc %in% 1:4, p < 0L, ),
bor3(jlc %in% 1:4, p < 0L, ))
expect_equal(or3s(jld %in% 1:4, i < 1L, ),
bor3(jld %in% 1:4, i < 1L, ))
expect_equal(or3s(jle %in% 1:4, v < 9L, ),
bor3(jle %in% 1:4, v < 9L, ))
expect_equal(or3s(jlf %in% 1:4, l < 0L, s <= 0L),
bor3(jlf %in% 1:4, l < 0L, s <= 0L))
expect_equal(or3s(jlg %in% 1:4, d < 1L, v <= 1L),
bor3(jlg %in% 1:4, d < 1L, v <= 1L))
expect_equal(or3s(jlh %in% 1:4, n < 9L, z <= 9L),
bor3(jlh %in% 1:4, n < 9L, z <= 9L))
expect_equal(or3s(jli %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jli %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jlj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jlj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jlk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jlk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jll %in% c(4L, -3L, 2L, 7L, 8L), , v == 0L),
bor3(jll %in% c(4L, -3L, 2L, 7L, 8L), , v == 0L))
expect_equal(or3s(jlm %in% c(4L, -3L, 2L, 7L, 8L), , n == 1L),
bor3(jlm %in% c(4L, -3L, 2L, 7L, 8L), , n == 1L))
expect_equal(or3s(jln %in% c(4L, -3L, 2L, 7L, 8L), , c == 9L),
bor3(jln %in% c(4L, -3L, 2L, 7L, 8L), , c == 9L))
expect_equal(or3s(jlo %in% c(4L, -3L, 2L, 7L, 8L), o < 0L, ),
bor3(jlo %in% c(4L, -3L, 2L, 7L, 8L), o < 0L, ))
expect_equal(or3s(jlp %in% c(4L, -3L, 2L, 7L, 8L), t < 1L, ),
bor3(jlp %in% c(4L, -3L, 2L, 7L, 8L), t < 1L, ))
expect_equal(or3s(jlq %in% c(4L, -3L, 2L, 7L, 8L), w < 9L, ),
bor3(jlq %in% c(4L, -3L, 2L, 7L, 8L), w < 9L, ))
expect_equal(or3s(jlr %in% c(4L, -3L, 2L, 7L, 8L), i < 0L, a == 0L),
bor3(jlr %in% c(4L, -3L, 2L, 7L, 8L), i < 0L, a == 0L))
expect_equal(or3s(jls %in% c(4L, -3L, 2L, 7L, 8L), n < 1L, t == 1L),
bor3(jls %in% c(4L, -3L, 2L, 7L, 8L), n < 1L, t == 1L))
expect_equal(or3s(jlt %in% c(4L, -3L, 2L, 7L, 8L), w < 9L, n == 9L),
bor3(jlt %in% c(4L, -3L, 2L, 7L, 8L), w < 9L, n == 9L))
expect_equal(or3s(jlu %in% 1:4, , ),
bor3(jlu %in% 1:4, , ))
expect_equal(or3s(jlv %in% 1:4, , ),
bor3(jlv %in% 1:4, , ))
expect_equal(or3s(jlw %in% 1:4, , ),
bor3(jlw %in% 1:4, , ))
expect_equal(or3s(jlx %in% 1:4, , j == 0L),
bor3(jlx %in% 1:4, , j == 0L))
expect_equal(or3s(jly %in% 1:4, , z == 1L),
bor3(jly %in% 1:4, , z == 1L))
expect_equal(or3s(jlz %in% 1:4, , n == 9L),
bor3(jlz %in% 1:4, , n == 9L))
expect_equal(or3s(jma %in% 1:4, l < 0L, ),
bor3(jma %in% 1:4, l < 0L, ))
expect_equal(or3s(jmb %in% 1:4, r < 1L, ),
bor3(jmb %in% 1:4, r < 1L, ))
expect_equal(or3s(jmc %in% 1:4, g < 9L, ),
bor3(jmc %in% 1:4, g < 9L, ))
expect_equal(or3s(jmd %in% 1:4, z < 0L, c == 0L),
bor3(jmd %in% 1:4, z < 0L, c == 0L))
expect_equal(or3s(jme %in% 1:4, n < 1L, s == 1L),
bor3(jme %in% 1:4, n < 1L, s == 1L))
expect_equal(or3s(jmf %in% 1:4, a < 9L, g == 9L),
bor3(jmf %in% 1:4, a < 9L, g == 9L))
expect_equal(or3s(jmg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jmg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jmh %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jmh %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jmi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jmi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jmj %in% c(4L, -3L, 2L, 7L, 8L), , o > 0L),
bor3(jmj %in% c(4L, -3L, 2L, 7L, 8L), , o > 0L))
expect_equal(or3s(jmk %in% c(4L, -3L, 2L, 7L, 8L), , z > 1L),
bor3(jmk %in% c(4L, -3L, 2L, 7L, 8L), , z > 1L))
expect_equal(or3s(jml %in% c(4L, -3L, 2L, 7L, 8L), , t > 9L),
bor3(jml %in% c(4L, -3L, 2L, 7L, 8L), , t > 9L))
expect_equal(or3s(jmm %in% c(4L, -3L, 2L, 7L, 8L), w < 0L, ),
bor3(jmm %in% c(4L, -3L, 2L, 7L, 8L), w < 0L, ))
expect_equal(or3s(jmn %in% c(4L, -3L, 2L, 7L, 8L), d < 1L, ),
bor3(jmn %in% c(4L, -3L, 2L, 7L, 8L), d < 1L, ))
expect_equal(or3s(jmo %in% c(4L, -3L, 2L, 7L, 8L), e < 9L, ),
bor3(jmo %in% c(4L, -3L, 2L, 7L, 8L), e < 9L, ))
expect_equal(or3s(jmp %in% c(4L, -3L, 2L, 7L, 8L), w < 0L, n > 0L),
bor3(jmp %in% c(4L, -3L, 2L, 7L, 8L), w < 0L, n > 0L))
expect_equal(or3s(jmq %in% c(4L, -3L, 2L, 7L, 8L), a < 1L, o > 1L),
bor3(jmq %in% c(4L, -3L, 2L, 7L, 8L), a < 1L, o > 1L))
expect_equal(or3s(jmr %in% c(4L, -3L, 2L, 7L, 8L), g < 9L, l > 9L),
bor3(jmr %in% c(4L, -3L, 2L, 7L, 8L), g < 9L, l > 9L))
expect_equal(or3s(jms %in% 1:4, , ),
bor3(jms %in% 1:4, , ))
expect_equal(or3s(jmt %in% 1:4, , ),
bor3(jmt %in% 1:4, , ))
expect_equal(or3s(jmu %in% 1:4, , ),
bor3(jmu %in% 1:4, , ))
expect_equal(or3s(jmv %in% 1:4, , e > 0L),
bor3(jmv %in% 1:4, , e > 0L))
expect_equal(or3s(jmw %in% 1:4, , n > 1L),
bor3(jmw %in% 1:4, , n > 1L))
expect_equal(or3s(jmx %in% 1:4, , l > 9L),
bor3(jmx %in% 1:4, , l > 9L))
expect_equal(or3s(jmy %in% 1:4, q < 0L, ),
bor3(jmy %in% 1:4, q < 0L, ))
expect_equal(or3s(jmz %in% 1:4, a < 1L, ),
bor3(jmz %in% 1:4, a < 1L, ))
expect_equal(or3s(jna %in% 1:4, x < 9L, ),
bor3(jna %in% 1:4, x < 9L, ))
expect_equal(or3s(jnb %in% 1:4, j < 0L, n > 0L),
bor3(jnb %in% 1:4, j < 0L, n > 0L))
expect_equal(or3s(jnc %in% 1:4, x < 1L, b > 1L),
bor3(jnc %in% 1:4, x < 1L, b > 1L))
expect_equal(or3s(jnd %in% 1:4, k < 9L, n > 9L),
bor3(jnd %in% 1:4, k < 9L, n > 9L))
expect_equal(or3s(jne %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jne %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jnf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jnf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jng %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jng %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jnh %in% c(4L, -3L, 2L, 7L, 8L), , w >= 0L),
bor3(jnh %in% c(4L, -3L, 2L, 7L, 8L), , w >= 0L))
expect_equal(or3s(jni %in% c(4L, -3L, 2L, 7L, 8L), , v >= 1L),
bor3(jni %in% c(4L, -3L, 2L, 7L, 8L), , v >= 1L))
expect_equal(or3s(jnj %in% c(4L, -3L, 2L, 7L, 8L), , j >= 9L),
bor3(jnj %in% c(4L, -3L, 2L, 7L, 8L), , j >= 9L))
expect_equal(or3s(jnk %in% c(4L, -3L, 2L, 7L, 8L), e < 0L, ),
bor3(jnk %in% c(4L, -3L, 2L, 7L, 8L), e < 0L, ))
expect_equal(or3s(jnl %in% c(4L, -3L, 2L, 7L, 8L), j < 1L, ),
bor3(jnl %in% c(4L, -3L, 2L, 7L, 8L), j < 1L, ))
expect_equal(or3s(jnm %in% c(4L, -3L, 2L, 7L, 8L), i < 9L, ),
bor3(jnm %in% c(4L, -3L, 2L, 7L, 8L), i < 9L, ))
expect_equal(or3s(jnn %in% c(4L, -3L, 2L, 7L, 8L), p < 0L, q >= 0L),
bor3(jnn %in% c(4L, -3L, 2L, 7L, 8L), p < 0L, q >= 0L))
expect_equal(or3s(jno %in% c(4L, -3L, 2L, 7L, 8L), s < 1L, n >= 1L),
bor3(jno %in% c(4L, -3L, 2L, 7L, 8L), s < 1L, n >= 1L))
expect_equal(or3s(jnp %in% c(4L, -3L, 2L, 7L, 8L), d < 9L, n >= 9L),
bor3(jnp %in% c(4L, -3L, 2L, 7L, 8L), d < 9L, n >= 9L))
expect_equal(or3s(jnq %in% 1:4, , ),
bor3(jnq %in% 1:4, , ))
expect_equal(or3s(jnr %in% 1:4, , ),
bor3(jnr %in% 1:4, , ))
expect_equal(or3s(jns %in% 1:4, , ),
bor3(jns %in% 1:4, , ))
expect_equal(or3s(jnt %in% 1:4, , v >= 0L),
bor3(jnt %in% 1:4, , v >= 0L))
expect_equal(or3s(jnu %in% 1:4, , i >= 1L),
bor3(jnu %in% 1:4, , i >= 1L))
expect_equal(or3s(jnv %in% 1:4, , s >= 9L),
bor3(jnv %in% 1:4, , s >= 9L))
expect_equal(or3s(jnw %in% 1:4, c < 0L, ),
bor3(jnw %in% 1:4, c < 0L, ))
expect_equal(or3s(jnx %in% 1:4, s < 1L, ),
bor3(jnx %in% 1:4, s < 1L, ))
expect_equal(or3s(jny %in% 1:4, x < 9L, ),
bor3(jny %in% 1:4, x < 9L, ))
expect_equal(or3s(jnz %in% 1:4, w < 0L, o >= 0L),
bor3(jnz %in% 1:4, w < 0L, o >= 0L))
expect_equal(or3s(joa %in% 1:4, g < 1L, r >= 1L),
bor3(joa %in% 1:4, g < 1L, r >= 1L))
expect_equal(or3s(job %in% 1:4, o < 9L, y >= 9L),
bor3(job %in% 1:4, o < 9L, y >= 9L))
expect_equal(or3s(joc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(joc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jod %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jod %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(joe %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(joe %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jof %in% c(4L, -3L, 2L, 7L, 8L), , logi_k),
bor3(jof %in% c(4L, -3L, 2L, 7L, 8L), , logi_k))
expect_equal(or3s(jog %in% c(4L, -3L, 2L, 7L, 8L), , logi_s),
bor3(jog %in% c(4L, -3L, 2L, 7L, 8L), , logi_s))
expect_equal(or3s(joh %in% c(4L, -3L, 2L, 7L, 8L), , logi_z),
bor3(joh %in% c(4L, -3L, 2L, 7L, 8L), , logi_z))
expect_equal(or3s(joi %in% c(4L, -3L, 2L, 7L, 8L), a <= 0L, ),
bor3(joi %in% c(4L, -3L, 2L, 7L, 8L), a <= 0L, ))
expect_equal(or3s(joj %in% c(4L, -3L, 2L, 7L, 8L), s <= 1L, ),
bor3(joj %in% c(4L, -3L, 2L, 7L, 8L), s <= 1L, ))
expect_equal(or3s(jok %in% c(4L, -3L, 2L, 7L, 8L), y <= 9L, ),
bor3(jok %in% c(4L, -3L, 2L, 7L, 8L), y <= 9L, ))
expect_equal(or3s(jol %in% c(4L, -3L, 2L, 7L, 8L), f <= 0L, logi_p),
bor3(jol %in% c(4L, -3L, 2L, 7L, 8L), f <= 0L, logi_p))
expect_equal(or3s(jom %in% c(4L, -3L, 2L, 7L, 8L), f <= 1L, logi_n),
bor3(jom %in% c(4L, -3L, 2L, 7L, 8L), f <= 1L, logi_n))
expect_equal(or3s(jon %in% c(4L, -3L, 2L, 7L, 8L), x <= 9L, logi_y),
bor3(jon %in% c(4L, -3L, 2L, 7L, 8L), x <= 9L, logi_y))
expect_equal(or3s(joo %in% 1:4, , ),
bor3(joo %in% 1:4, , ))
expect_equal(or3s(jop %in% 1:4, , ),
bor3(jop %in% 1:4, , ))
expect_equal(or3s(joq %in% 1:4, , ),
bor3(joq %in% 1:4, , ))
expect_equal(or3s(jor %in% 1:4, , logi_s),
bor3(jor %in% 1:4, , logi_s))
expect_equal(or3s(jos %in% 1:4, , logi_e),
bor3(jos %in% 1:4, , logi_e))
expect_equal(or3s(jot %in% 1:4, , logi_p),
bor3(jot %in% 1:4, , logi_p))
expect_equal(or3s(jou %in% 1:4, s <= 0L, ),
bor3(jou %in% 1:4, s <= 0L, ))
expect_equal(or3s(jov %in% 1:4, l <= 1L, ),
bor3(jov %in% 1:4, l <= 1L, ))
expect_equal(or3s(jow %in% 1:4, h <= 9L, ),
bor3(jow %in% 1:4, h <= 9L, ))
expect_equal(or3s(jox %in% 1:4, x <= 0L, logi_s),
bor3(jox %in% 1:4, x <= 0L, logi_s))
expect_equal(or3s(joy %in% 1:4, h <= 1L, logi_u),
bor3(joy %in% 1:4, h <= 1L, logi_u))
expect_equal(or3s(joz %in% 1:4, n <= 9L, logi_z),
bor3(joz %in% 1:4, n <= 9L, logi_z))
expect_equal(or3s(jpa %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jpa %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jpb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jpb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jpc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jpc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jpd %in% c(4L, -3L, 2L, 7L, 8L), , !logi_t),
bor3(jpd %in% c(4L, -3L, 2L, 7L, 8L), , !logi_t))
expect_equal(or3s(jpe %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a),
bor3(jpe %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a))
expect_equal(or3s(jpf %in% c(4L, -3L, 2L, 7L, 8L), , !logi_h),
bor3(jpf %in% c(4L, -3L, 2L, 7L, 8L), , !logi_h))
expect_equal(or3s(jpg %in% c(4L, -3L, 2L, 7L, 8L), w <= 0L, ),
bor3(jpg %in% c(4L, -3L, 2L, 7L, 8L), w <= 0L, ))
expect_equal(or3s(jph %in% c(4L, -3L, 2L, 7L, 8L), s <= 1L, ),
bor3(jph %in% c(4L, -3L, 2L, 7L, 8L), s <= 1L, ))
expect_equal(or3s(jpi %in% c(4L, -3L, 2L, 7L, 8L), w <= 9L, ),
bor3(jpi %in% c(4L, -3L, 2L, 7L, 8L), w <= 9L, ))
expect_equal(or3s(jpj %in% c(4L, -3L, 2L, 7L, 8L), j <= 0L, !logi_q),
bor3(jpj %in% c(4L, -3L, 2L, 7L, 8L), j <= 0L, !logi_q))
expect_equal(or3s(jpk %in% c(4L, -3L, 2L, 7L, 8L), v <= 1L, !logi_x),
bor3(jpk %in% c(4L, -3L, 2L, 7L, 8L), v <= 1L, !logi_x))
expect_equal(or3s(jpl %in% c(4L, -3L, 2L, 7L, 8L), a <= 9L, !logi_h),
bor3(jpl %in% c(4L, -3L, 2L, 7L, 8L), a <= 9L, !logi_h))
expect_equal(or3s(jpm %in% 1:4, , ),
bor3(jpm %in% 1:4, , ))
expect_equal(or3s(jpn %in% 1:4, , ),
bor3(jpn %in% 1:4, , ))
expect_equal(or3s(jpo %in% 1:4, , ),
bor3(jpo %in% 1:4, , ))
expect_equal(or3s(jpp %in% 1:4, , !logi_s),
bor3(jpp %in% 1:4, , !logi_s))
expect_equal(or3s(jpq %in% 1:4, , !logi_z),
bor3(jpq %in% 1:4, , !logi_z))
expect_equal(or3s(jpr %in% 1:4, , !logi_f),
bor3(jpr %in% 1:4, , !logi_f))
expect_equal(or3s(jps %in% 1:4, z <= 0L, ),
bor3(jps %in% 1:4, z <= 0L, ))
expect_equal(or3s(jpt %in% 1:4, k <= 1L, ),
bor3(jpt %in% 1:4, k <= 1L, ))
expect_equal(or3s(jpu %in% 1:4, d <= 9L, ),
bor3(jpu %in% 1:4, d <= 9L, ))
expect_equal(or3s(jpv %in% 1:4, i <= 0L, !logi_a),
bor3(jpv %in% 1:4, i <= 0L, !logi_a))
expect_equal(or3s(jpw %in% 1:4, d <= 1L, !logi_e),
bor3(jpw %in% 1:4, d <= 1L, !logi_e))
expect_equal(or3s(jpx %in% 1:4, b <= 9L, !logi_u),
bor3(jpx %in% 1:4, b <= 9L, !logi_u))
expect_equal(or3s(jpy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jpy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jpz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jpz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jqa %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jqa %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jqb %in% c(4L, -3L, 2L, 7L, 8L), , o != 0L),
bor3(jqb %in% c(4L, -3L, 2L, 7L, 8L), , o != 0L))
expect_equal(or3s(jqc %in% c(4L, -3L, 2L, 7L, 8L), , o != 1L),
bor3(jqc %in% c(4L, -3L, 2L, 7L, 8L), , o != 1L))
expect_equal(or3s(jqd %in% c(4L, -3L, 2L, 7L, 8L), , v != 9L),
bor3(jqd %in% c(4L, -3L, 2L, 7L, 8L), , v != 9L))
expect_equal(or3s(jqe %in% c(4L, -3L, 2L, 7L, 8L), q <= 0L, ),
bor3(jqe %in% c(4L, -3L, 2L, 7L, 8L), q <= 0L, ))
expect_equal(or3s(jqf %in% c(4L, -3L, 2L, 7L, 8L), j <= 1L, ),
bor3(jqf %in% c(4L, -3L, 2L, 7L, 8L), j <= 1L, ))
expect_equal(or3s(jqg %in% c(4L, -3L, 2L, 7L, 8L), f <= 9L, ),
bor3(jqg %in% c(4L, -3L, 2L, 7L, 8L), f <= 9L, ))
expect_equal(or3s(jqh %in% c(4L, -3L, 2L, 7L, 8L), m <= 0L, s != 0L),
bor3(jqh %in% c(4L, -3L, 2L, 7L, 8L), m <= 0L, s != 0L))
expect_equal(or3s(jqi %in% c(4L, -3L, 2L, 7L, 8L), f <= 1L, f != 1L),
bor3(jqi %in% c(4L, -3L, 2L, 7L, 8L), f <= 1L, f != 1L))
expect_equal(or3s(jqj %in% c(4L, -3L, 2L, 7L, 8L), v <= 9L, u != 9L),
bor3(jqj %in% c(4L, -3L, 2L, 7L, 8L), v <= 9L, u != 9L))
expect_equal(or3s(jqk %in% 1:4, , ),
bor3(jqk %in% 1:4, , ))
expect_equal(or3s(jql %in% 1:4, , ),
bor3(jql %in% 1:4, , ))
expect_equal(or3s(jqm %in% 1:4, , ),
bor3(jqm %in% 1:4, , ))
expect_equal(or3s(jqn %in% 1:4, , n != 0L),
bor3(jqn %in% 1:4, , n != 0L))
expect_equal(or3s(jqo %in% 1:4, , v != 1L),
bor3(jqo %in% 1:4, , v != 1L))
expect_equal(or3s(jqp %in% 1:4, , y != 9L),
bor3(jqp %in% 1:4, , y != 9L))
expect_equal(or3s(jqq %in% 1:4, b <= 0L, ),
bor3(jqq %in% 1:4, b <= 0L, ))
expect_equal(or3s(jqr %in% 1:4, b <= 1L, ),
bor3(jqr %in% 1:4, b <= 1L, ))
expect_equal(or3s(jqs %in% 1:4, d <= 9L, ),
bor3(jqs %in% 1:4, d <= 9L, ))
expect_equal(or3s(jqt %in% 1:4, p <= 0L, u != 0L),
bor3(jqt %in% 1:4, p <= 0L, u != 0L))
expect_equal(or3s(jqu %in% 1:4, y <= 1L, k != 1L),
bor3(jqu %in% 1:4, y <= 1L, k != 1L))
expect_equal(or3s(jqv %in% 1:4, m <= 9L, k != 9L),
bor3(jqv %in% 1:4, m <= 9L, k != 9L))
expect_equal(or3s(jqw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jqw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jqx %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jqx %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jqy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jqy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jqz %in% c(4L, -3L, 2L, 7L, 8L), , q %between% c(-1L, 1L)),
bor3(jqz %in% c(4L, -3L, 2L, 7L, 8L), , q %between% c(-1L, 1L)))
expect_equal(or3s(jra %in% c(4L, -3L, 2L, 7L, 8L), , v %between% c(-1L, 1L)),
bor3(jra %in% c(4L, -3L, 2L, 7L, 8L), , v %between% c(-1L, 1L)))
expect_equal(or3s(jrb %in% c(4L, -3L, 2L, 7L, 8L), , m %between% c(-1L, 1L)),
bor3(jrb %in% c(4L, -3L, 2L, 7L, 8L), , m %between% c(-1L, 1L)))
expect_equal(or3s(jrc %in% c(4L, -3L, 2L, 7L, 8L), k <= 0L, ),
bor3(jrc %in% c(4L, -3L, 2L, 7L, 8L), k <= 0L, ))
expect_equal(or3s(jrd %in% c(4L, -3L, 2L, 7L, 8L), v <= 1L, ),
bor3(jrd %in% c(4L, -3L, 2L, 7L, 8L), v <= 1L, ))
expect_equal(or3s(jre %in% c(4L, -3L, 2L, 7L, 8L), v <= 9L, ),
bor3(jre %in% c(4L, -3L, 2L, 7L, 8L), v <= 9L, ))
expect_equal(or3s(jrf %in% c(4L, -3L, 2L, 7L, 8L), e <= 0L, q %between% c(-1L, 1L)),
bor3(jrf %in% c(4L, -3L, 2L, 7L, 8L), e <= 0L, q %between% c(-1L, 1L)))
expect_equal(or3s(jrg %in% c(4L, -3L, 2L, 7L, 8L), g <= 1L, y %between% c(-1L, 1L)),
bor3(jrg %in% c(4L, -3L, 2L, 7L, 8L), g <= 1L, y %between% c(-1L, 1L)))
expect_equal(or3s(jrh %in% c(4L, -3L, 2L, 7L, 8L), s <= 9L, z %between% c(-1L, 1L)),
bor3(jrh %in% c(4L, -3L, 2L, 7L, 8L), s <= 9L, z %between% c(-1L, 1L)))
expect_equal(or3s(jri %in% 1:4, , ),
bor3(jri %in% 1:4, , ))
expect_equal(or3s(jrj %in% 1:4, , ),
bor3(jrj %in% 1:4, , ))
expect_equal(or3s(jrk %in% 1:4, , ),
bor3(jrk %in% 1:4, , ))
expect_equal(or3s(jrl %in% 1:4, , s %between% c(-1L, 1L)),
bor3(jrl %in% 1:4, , s %between% c(-1L, 1L)))
expect_equal(or3s(jrm %in% 1:4, , e %between% c(-1L, 1L)),
bor3(jrm %in% 1:4, , e %between% c(-1L, 1L)))
expect_equal(or3s(jrn %in% 1:4, , i %between% c(-1L, 1L)),
bor3(jrn %in% 1:4, , i %between% c(-1L, 1L)))
expect_equal(or3s(jro %in% 1:4, h <= 0L, ),
bor3(jro %in% 1:4, h <= 0L, ))
expect_equal(or3s(jrp %in% 1:4, s <= 1L, ),
bor3(jrp %in% 1:4, s <= 1L, ))
expect_equal(or3s(jrq %in% 1:4, l <= 9L, ),
bor3(jrq %in% 1:4, l <= 9L, ))
expect_equal(or3s(jrr %in% 1:4, h <= 0L, f %between% c(-1L, 1L)),
bor3(jrr %in% 1:4, h <= 0L, f %between% c(-1L, 1L)))
expect_equal(or3s(jrs %in% 1:4, h <= 1L, l %between% c(-1L, 1L)),
bor3(jrs %in% 1:4, h <= 1L, l %between% c(-1L, 1L)))
expect_equal(or3s(jrt %in% 1:4, r <= 9L, g %between% c(-1L, 1L)),
bor3(jrt %in% 1:4, r <= 9L, g %between% c(-1L, 1L)))
expect_equal(or3s(jru %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jru %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jrv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jrv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jrw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jrw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jrx %in% c(4L, -3L, 2L, 7L, 8L), , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jrx %in% c(4L, -3L, 2L, 7L, 8L), , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jry %in% c(4L, -3L, 2L, 7L, 8L), , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jry %in% c(4L, -3L, 2L, 7L, 8L), , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jrz %in% c(4L, -3L, 2L, 7L, 8L), , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jrz %in% c(4L, -3L, 2L, 7L, 8L), , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jsa %in% c(4L, -3L, 2L, 7L, 8L), e <= 0L, ),
bor3(jsa %in% c(4L, -3L, 2L, 7L, 8L), e <= 0L, ))
expect_equal(or3s(jsb %in% c(4L, -3L, 2L, 7L, 8L), y <= 1L, ),
bor3(jsb %in% c(4L, -3L, 2L, 7L, 8L), y <= 1L, ))
expect_equal(or3s(jsc %in% c(4L, -3L, 2L, 7L, 8L), c <= 9L, ),
bor3(jsc %in% c(4L, -3L, 2L, 7L, 8L), c <= 9L, ))
expect_equal(or3s(jsd %in% c(4L, -3L, 2L, 7L, 8L), j <= 0L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jsd %in% c(4L, -3L, 2L, 7L, 8L), j <= 0L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jse %in% c(4L, -3L, 2L, 7L, 8L), b <= 1L, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jse %in% c(4L, -3L, 2L, 7L, 8L), b <= 1L, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jsf %in% c(4L, -3L, 2L, 7L, 8L), w <= 9L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(jsf %in% c(4L, -3L, 2L, 7L, 8L), w <= 9L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(jsg %in% 1:4, , ),
bor3(jsg %in% 1:4, , ))
expect_equal(or3s(jsh %in% 1:4, , ),
bor3(jsh %in% 1:4, , ))
expect_equal(or3s(jsi %in% 1:4, , ),
bor3(jsi %in% 1:4, , ))
expect_equal(or3s(jsj %in% 1:4, , b %in% 1:4),
bor3(jsj %in% 1:4, , b %in% 1:4))
expect_equal(or3s(jsk %in% 1:4, , x %in% 1:4),
bor3(jsk %in% 1:4, , x %in% 1:4))
expect_equal(or3s(jsl %in% 1:4, , x %in% 1:4),
bor3(jsl %in% 1:4, , x %in% 1:4))
expect_equal(or3s(jsm %in% 1:4, p <= 0L, ),
bor3(jsm %in% 1:4, p <= 0L, ))
expect_equal(or3s(jsn %in% 1:4, b <= 1L, ),
bor3(jsn %in% 1:4, b <= 1L, ))
expect_equal(or3s(jso %in% 1:4, g <= 9L, ),
bor3(jso %in% 1:4, g <= 9L, ))
expect_equal(or3s(jsp %in% 1:4, w <= 0L, k %in% 1:4),
bor3(jsp %in% 1:4, w <= 0L, k %in% 1:4))
expect_equal(or3s(jsq %in% 1:4, q <= 1L, k %in% 1:4),
bor3(jsq %in% 1:4, q <= 1L, k %in% 1:4))
expect_equal(or3s(jsr %in% 1:4, f <= 9L, b %in% 1:4),
bor3(jsr %in% 1:4, f <= 9L, b %in% 1:4))
expect_equal(or3s(jss %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jss %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jst %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jst %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jsu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jsu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jsv %in% c(4L, -3L, 2L, 7L, 8L), , g < 0L),
bor3(jsv %in% c(4L, -3L, 2L, 7L, 8L), , g < 0L))
expect_equal(or3s(jsw %in% c(4L, -3L, 2L, 7L, 8L), , v < 1L),
bor3(jsw %in% c(4L, -3L, 2L, 7L, 8L), , v < 1L))
expect_equal(or3s(jsx %in% c(4L, -3L, 2L, 7L, 8L), , h < 9L),
bor3(jsx %in% c(4L, -3L, 2L, 7L, 8L), , h < 9L))
expect_equal(or3s(jsy %in% c(4L, -3L, 2L, 7L, 8L), p <= 0L, ),
bor3(jsy %in% c(4L, -3L, 2L, 7L, 8L), p <= 0L, ))
expect_equal(or3s(jsz %in% c(4L, -3L, 2L, 7L, 8L), d <= 1L, ),
bor3(jsz %in% c(4L, -3L, 2L, 7L, 8L), d <= 1L, ))
expect_equal(or3s(jta %in% c(4L, -3L, 2L, 7L, 8L), n <= 9L, ),
bor3(jta %in% c(4L, -3L, 2L, 7L, 8L), n <= 9L, ))
expect_equal(or3s(jtb %in% c(4L, -3L, 2L, 7L, 8L), r <= 0L, u < 0L),
bor3(jtb %in% c(4L, -3L, 2L, 7L, 8L), r <= 0L, u < 0L))
expect_equal(or3s(jtc %in% c(4L, -3L, 2L, 7L, 8L), x <= 1L, w < 1L),
bor3(jtc %in% c(4L, -3L, 2L, 7L, 8L), x <= 1L, w < 1L))
expect_equal(or3s(jtd %in% c(4L, -3L, 2L, 7L, 8L), c <= 9L, m < 9L),
bor3(jtd %in% c(4L, -3L, 2L, 7L, 8L), c <= 9L, m < 9L))
expect_equal(or3s(jte %in% 1:4, , ),
bor3(jte %in% 1:4, , ))
expect_equal(or3s(jtf %in% 1:4, , ),
bor3(jtf %in% 1:4, , ))
expect_equal(or3s(jtg %in% 1:4, , ),
bor3(jtg %in% 1:4, , ))
expect_equal(or3s(jth %in% 1:4, , q < 0L),
bor3(jth %in% 1:4, , q < 0L))
expect_equal(or3s(jti %in% 1:4, , t < 1L),
bor3(jti %in% 1:4, , t < 1L))
expect_equal(or3s(jtj %in% 1:4, , m < 9L),
bor3(jtj %in% 1:4, , m < 9L))
expect_equal(or3s(jtk %in% 1:4, s <= 0L, ),
bor3(jtk %in% 1:4, s <= 0L, ))
expect_equal(or3s(jtl %in% 1:4, l <= 1L, ),
bor3(jtl %in% 1:4, l <= 1L, ))
expect_equal(or3s(jtm %in% 1:4, v <= 9L, ),
bor3(jtm %in% 1:4, v <= 9L, ))
expect_equal(or3s(jtn %in% 1:4, i <= 0L, e < 0L),
bor3(jtn %in% 1:4, i <= 0L, e < 0L))
expect_equal(or3s(jto %in% 1:4, j <= 1L, y < 1L),
bor3(jto %in% 1:4, j <= 1L, y < 1L))
expect_equal(or3s(jtp %in% 1:4, o <= 9L, x < 9L),
bor3(jtp %in% 1:4, o <= 9L, x < 9L))
expect_equal(or3s(jtq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jtq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jtr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jtr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jts %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jts %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jtt %in% c(4L, -3L, 2L, 7L, 8L), , t <= 0L),
bor3(jtt %in% c(4L, -3L, 2L, 7L, 8L), , t <= 0L))
expect_equal(or3s(jtu %in% c(4L, -3L, 2L, 7L, 8L), , y <= 1L),
bor3(jtu %in% c(4L, -3L, 2L, 7L, 8L), , y <= 1L))
expect_equal(or3s(jtv %in% c(4L, -3L, 2L, 7L, 8L), , q <= 9L),
bor3(jtv %in% c(4L, -3L, 2L, 7L, 8L), , q <= 9L))
expect_equal(or3s(jtw %in% c(4L, -3L, 2L, 7L, 8L), z <= 0L, ),
bor3(jtw %in% c(4L, -3L, 2L, 7L, 8L), z <= 0L, ))
expect_equal(or3s(jtx %in% c(4L, -3L, 2L, 7L, 8L), p <= 1L, ),
bor3(jtx %in% c(4L, -3L, 2L, 7L, 8L), p <= 1L, ))
expect_equal(or3s(jty %in% c(4L, -3L, 2L, 7L, 8L), l <= 9L, ),
bor3(jty %in% c(4L, -3L, 2L, 7L, 8L), l <= 9L, ))
expect_equal(or3s(jtz %in% c(4L, -3L, 2L, 7L, 8L), d <= 0L, y <= 0L),
bor3(jtz %in% c(4L, -3L, 2L, 7L, 8L), d <= 0L, y <= 0L))
expect_equal(or3s(jua %in% c(4L, -3L, 2L, 7L, 8L), s <= 1L, j <= 1L),
bor3(jua %in% c(4L, -3L, 2L, 7L, 8L), s <= 1L, j <= 1L))
expect_equal(or3s(jub %in% c(4L, -3L, 2L, 7L, 8L), j <= 9L, x <= 9L),
bor3(jub %in% c(4L, -3L, 2L, 7L, 8L), j <= 9L, x <= 9L))
expect_equal(or3s(juc %in% 1:4, , ),
bor3(juc %in% 1:4, , ))
expect_equal(or3s(jud %in% 1:4, , ),
bor3(jud %in% 1:4, , ))
expect_equal(or3s(jue %in% 1:4, , ),
bor3(jue %in% 1:4, , ))
expect_equal(or3s(juf %in% 1:4, , x <= 0L),
bor3(juf %in% 1:4, , x <= 0L))
expect_equal(or3s(jug %in% 1:4, , n <= 1L),
bor3(jug %in% 1:4, , n <= 1L))
expect_equal(or3s(juh %in% 1:4, , v <= 9L),
bor3(juh %in% 1:4, , v <= 9L))
expect_equal(or3s(jui %in% 1:4, v <= 0L, ),
bor3(jui %in% 1:4, v <= 0L, ))
expect_equal(or3s(juj %in% 1:4, o <= 1L, ),
bor3(juj %in% 1:4, o <= 1L, ))
expect_equal(or3s(juk %in% 1:4, b <= 9L, ),
bor3(juk %in% 1:4, b <= 9L, ))
expect_equal(or3s(jul %in% 1:4, j <= 0L, h <= 0L),
bor3(jul %in% 1:4, j <= 0L, h <= 0L))
expect_equal(or3s(jum %in% 1:4, a <= 1L, k <= 1L),
bor3(jum %in% 1:4, a <= 1L, k <= 1L))
expect_equal(or3s(jun %in% 1:4, x <= 9L, u <= 9L),
bor3(jun %in% 1:4, x <= 9L, u <= 9L))
expect_equal(or3s(juo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(juo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jup %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jup %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(juq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(juq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jur %in% c(4L, -3L, 2L, 7L, 8L), , u == 0L),
bor3(jur %in% c(4L, -3L, 2L, 7L, 8L), , u == 0L))
expect_equal(or3s(jus %in% c(4L, -3L, 2L, 7L, 8L), , k == 1L),
bor3(jus %in% c(4L, -3L, 2L, 7L, 8L), , k == 1L))
expect_equal(or3s(jut %in% c(4L, -3L, 2L, 7L, 8L), , r == 9L),
bor3(jut %in% c(4L, -3L, 2L, 7L, 8L), , r == 9L))
expect_equal(or3s(juu %in% c(4L, -3L, 2L, 7L, 8L), b <= 0L, ),
bor3(juu %in% c(4L, -3L, 2L, 7L, 8L), b <= 0L, ))
expect_equal(or3s(juv %in% c(4L, -3L, 2L, 7L, 8L), q <= 1L, ),
bor3(juv %in% c(4L, -3L, 2L, 7L, 8L), q <= 1L, ))
expect_equal(or3s(juw %in% c(4L, -3L, 2L, 7L, 8L), s <= 9L, ),
bor3(juw %in% c(4L, -3L, 2L, 7L, 8L), s <= 9L, ))
expect_equal(or3s(jux %in% c(4L, -3L, 2L, 7L, 8L), i <= 0L, t == 0L),
bor3(jux %in% c(4L, -3L, 2L, 7L, 8L), i <= 0L, t == 0L))
expect_equal(or3s(juy %in% c(4L, -3L, 2L, 7L, 8L), v <= 1L, p == 1L),
bor3(juy %in% c(4L, -3L, 2L, 7L, 8L), v <= 1L, p == 1L))
expect_equal(or3s(juz %in% c(4L, -3L, 2L, 7L, 8L), c <= 9L, u == 9L),
bor3(juz %in% c(4L, -3L, 2L, 7L, 8L), c <= 9L, u == 9L))
expect_equal(or3s(jva %in% 1:4, , ),
bor3(jva %in% 1:4, , ))
expect_equal(or3s(jvb %in% 1:4, , ),
bor3(jvb %in% 1:4, , ))
expect_equal(or3s(jvc %in% 1:4, , ),
bor3(jvc %in% 1:4, , ))
expect_equal(or3s(jvd %in% 1:4, , i == 0L),
bor3(jvd %in% 1:4, , i == 0L))
expect_equal(or3s(jve %in% 1:4, , j == 1L),
bor3(jve %in% 1:4, , j == 1L))
expect_equal(or3s(jvf %in% 1:4, , e == 9L),
bor3(jvf %in% 1:4, , e == 9L))
expect_equal(or3s(jvg %in% 1:4, c <= 0L, ),
bor3(jvg %in% 1:4, c <= 0L, ))
expect_equal(or3s(jvh %in% 1:4, x <= 1L, ),
bor3(jvh %in% 1:4, x <= 1L, ))
expect_equal(or3s(jvi %in% 1:4, d <= 9L, ),
bor3(jvi %in% 1:4, d <= 9L, ))
expect_equal(or3s(jvj %in% 1:4, i <= 0L, v == 0L),
bor3(jvj %in% 1:4, i <= 0L, v == 0L))
expect_equal(or3s(jvk %in% 1:4, j <= 1L, j == 1L),
bor3(jvk %in% 1:4, j <= 1L, j == 1L))
expect_equal(or3s(jvl %in% 1:4, f <= 9L, q == 9L),
bor3(jvl %in% 1:4, f <= 9L, q == 9L))
expect_equal(or3s(jvm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jvm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jvn %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jvn %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jvo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jvo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jvp %in% c(4L, -3L, 2L, 7L, 8L), , p > 0L),
bor3(jvp %in% c(4L, -3L, 2L, 7L, 8L), , p > 0L))
expect_equal(or3s(jvq %in% c(4L, -3L, 2L, 7L, 8L), , u > 1L),
bor3(jvq %in% c(4L, -3L, 2L, 7L, 8L), , u > 1L))
expect_equal(or3s(jvr %in% c(4L, -3L, 2L, 7L, 8L), , x > 9L),
bor3(jvr %in% c(4L, -3L, 2L, 7L, 8L), , x > 9L))
expect_equal(or3s(jvs %in% c(4L, -3L, 2L, 7L, 8L), k <= 0L, ),
bor3(jvs %in% c(4L, -3L, 2L, 7L, 8L), k <= 0L, ))
expect_equal(or3s(jvt %in% c(4L, -3L, 2L, 7L, 8L), x <= 1L, ),
bor3(jvt %in% c(4L, -3L, 2L, 7L, 8L), x <= 1L, ))
expect_equal(or3s(jvu %in% c(4L, -3L, 2L, 7L, 8L), z <= 9L, ),
bor3(jvu %in% c(4L, -3L, 2L, 7L, 8L), z <= 9L, ))
expect_equal(or3s(jvv %in% c(4L, -3L, 2L, 7L, 8L), s <= 0L, j > 0L),
bor3(jvv %in% c(4L, -3L, 2L, 7L, 8L), s <= 0L, j > 0L))
expect_equal(or3s(jvw %in% c(4L, -3L, 2L, 7L, 8L), u <= 1L, i > 1L),
bor3(jvw %in% c(4L, -3L, 2L, 7L, 8L), u <= 1L, i > 1L))
expect_equal(or3s(jvx %in% c(4L, -3L, 2L, 7L, 8L), m <= 9L, p > 9L),
bor3(jvx %in% c(4L, -3L, 2L, 7L, 8L), m <= 9L, p > 9L))
expect_equal(or3s(jvy %in% 1:4, , ),
bor3(jvy %in% 1:4, , ))
expect_equal(or3s(jvz %in% 1:4, , ),
bor3(jvz %in% 1:4, , ))
expect_equal(or3s(jwa %in% 1:4, , ),
bor3(jwa %in% 1:4, , ))
expect_equal(or3s(jwb %in% 1:4, , y > 0L),
bor3(jwb %in% 1:4, , y > 0L))
expect_equal(or3s(jwc %in% 1:4, , d > 1L),
bor3(jwc %in% 1:4, , d > 1L))
expect_equal(or3s(jwd %in% 1:4, , d > 9L),
bor3(jwd %in% 1:4, , d > 9L))
expect_equal(or3s(jwe %in% 1:4, h <= 0L, ),
bor3(jwe %in% 1:4, h <= 0L, ))
expect_equal(or3s(jwf %in% 1:4, n <= 1L, ),
bor3(jwf %in% 1:4, n <= 1L, ))
expect_equal(or3s(jwg %in% 1:4, r <= 9L, ),
bor3(jwg %in% 1:4, r <= 9L, ))
expect_equal(or3s(jwh %in% 1:4, l <= 0L, r > 0L),
bor3(jwh %in% 1:4, l <= 0L, r > 0L))
expect_equal(or3s(jwi %in% 1:4, i <= 1L, c > 1L),
bor3(jwi %in% 1:4, i <= 1L, c > 1L))
expect_equal(or3s(jwj %in% 1:4, u <= 9L, k > 9L),
bor3(jwj %in% 1:4, u <= 9L, k > 9L))
expect_equal(or3s(jwk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jwk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jwl %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jwl %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jwm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jwm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jwn %in% c(4L, -3L, 2L, 7L, 8L), , x >= 0L),
bor3(jwn %in% c(4L, -3L, 2L, 7L, 8L), , x >= 0L))
expect_equal(or3s(jwo %in% c(4L, -3L, 2L, 7L, 8L), , y >= 1L),
bor3(jwo %in% c(4L, -3L, 2L, 7L, 8L), , y >= 1L))
expect_equal(or3s(jwp %in% c(4L, -3L, 2L, 7L, 8L), , l >= 9L),
bor3(jwp %in% c(4L, -3L, 2L, 7L, 8L), , l >= 9L))
expect_equal(or3s(jwq %in% c(4L, -3L, 2L, 7L, 8L), a <= 0L, ),
bor3(jwq %in% c(4L, -3L, 2L, 7L, 8L), a <= 0L, ))
expect_equal(or3s(jwr %in% c(4L, -3L, 2L, 7L, 8L), n <= 1L, ),
bor3(jwr %in% c(4L, -3L, 2L, 7L, 8L), n <= 1L, ))
expect_equal(or3s(jws %in% c(4L, -3L, 2L, 7L, 8L), t <= 9L, ),
bor3(jws %in% c(4L, -3L, 2L, 7L, 8L), t <= 9L, ))
expect_equal(or3s(jwt %in% c(4L, -3L, 2L, 7L, 8L), r <= 0L, z >= 0L),
bor3(jwt %in% c(4L, -3L, 2L, 7L, 8L), r <= 0L, z >= 0L))
expect_equal(or3s(jwu %in% c(4L, -3L, 2L, 7L, 8L), r <= 1L, d >= 1L),
bor3(jwu %in% c(4L, -3L, 2L, 7L, 8L), r <= 1L, d >= 1L))
expect_equal(or3s(jwv %in% c(4L, -3L, 2L, 7L, 8L), t <= 9L, a >= 9L),
bor3(jwv %in% c(4L, -3L, 2L, 7L, 8L), t <= 9L, a >= 9L))
expect_equal(or3s(jww %in% 1:4, , ),
bor3(jww %in% 1:4, , ))
expect_equal(or3s(jwx %in% 1:4, , ),
bor3(jwx %in% 1:4, , ))
expect_equal(or3s(jwy %in% 1:4, , ),
bor3(jwy %in% 1:4, , ))
expect_equal(or3s(jwz %in% 1:4, , v >= 0L),
bor3(jwz %in% 1:4, , v >= 0L))
expect_equal(or3s(jxa %in% 1:4, , u >= 1L),
bor3(jxa %in% 1:4, , u >= 1L))
expect_equal(or3s(jxb %in% 1:4, , f >= 9L),
bor3(jxb %in% 1:4, , f >= 9L))
expect_equal(or3s(jxc %in% 1:4, q <= 0L, ),
bor3(jxc %in% 1:4, q <= 0L, ))
expect_equal(or3s(jxd %in% 1:4, w <= 1L, ),
bor3(jxd %in% 1:4, w <= 1L, ))
expect_equal(or3s(jxe %in% 1:4, l <= 9L, ),
bor3(jxe %in% 1:4, l <= 9L, ))
expect_equal(or3s(jxf %in% 1:4, u <= 0L, v >= 0L),
bor3(jxf %in% 1:4, u <= 0L, v >= 0L))
expect_equal(or3s(jxg %in% 1:4, k <= 1L, o >= 1L),
bor3(jxg %in% 1:4, k <= 1L, o >= 1L))
expect_equal(or3s(jxh %in% 1:4, z <= 9L, l >= 9L),
bor3(jxh %in% 1:4, z <= 9L, l >= 9L))
expect_equal(or3s(jxi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jxi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jxj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jxj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jxk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jxk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jxl %in% c(4L, -3L, 2L, 7L, 8L), , logi_b),
bor3(jxl %in% c(4L, -3L, 2L, 7L, 8L), , logi_b))
expect_equal(or3s(jxm %in% c(4L, -3L, 2L, 7L, 8L), , logi_q),
bor3(jxm %in% c(4L, -3L, 2L, 7L, 8L), , logi_q))
expect_equal(or3s(jxn %in% c(4L, -3L, 2L, 7L, 8L), , logi_j),
bor3(jxn %in% c(4L, -3L, 2L, 7L, 8L), , logi_j))
expect_equal(or3s(jxo %in% c(4L, -3L, 2L, 7L, 8L), v == 0L, ),
bor3(jxo %in% c(4L, -3L, 2L, 7L, 8L), v == 0L, ))
expect_equal(or3s(jxp %in% c(4L, -3L, 2L, 7L, 8L), a == 1L, ),
bor3(jxp %in% c(4L, -3L, 2L, 7L, 8L), a == 1L, ))
expect_equal(or3s(jxq %in% c(4L, -3L, 2L, 7L, 8L), g == 9L, ),
bor3(jxq %in% c(4L, -3L, 2L, 7L, 8L), g == 9L, ))
expect_equal(or3s(jxr %in% c(4L, -3L, 2L, 7L, 8L), j == 0L, logi_q),
bor3(jxr %in% c(4L, -3L, 2L, 7L, 8L), j == 0L, logi_q))
expect_equal(or3s(jxs %in% c(4L, -3L, 2L, 7L, 8L), u == 1L, logi_b),
bor3(jxs %in% c(4L, -3L, 2L, 7L, 8L), u == 1L, logi_b))
expect_equal(or3s(jxt %in% c(4L, -3L, 2L, 7L, 8L), z == 9L, logi_p),
bor3(jxt %in% c(4L, -3L, 2L, 7L, 8L), z == 9L, logi_p))
expect_equal(or3s(jxu %in% 1:4, , ),
bor3(jxu %in% 1:4, , ))
expect_equal(or3s(jxv %in% 1:4, , ),
bor3(jxv %in% 1:4, , ))
expect_equal(or3s(jxw %in% 1:4, , ),
bor3(jxw %in% 1:4, , ))
expect_equal(or3s(jxx %in% 1:4, , logi_a),
bor3(jxx %in% 1:4, , logi_a))
expect_equal(or3s(jxy %in% 1:4, , logi_v),
bor3(jxy %in% 1:4, , logi_v))
expect_equal(or3s(jxz %in% 1:4, , logi_m),
bor3(jxz %in% 1:4, , logi_m))
expect_equal(or3s(jya %in% 1:4, q == 0L, ),
bor3(jya %in% 1:4, q == 0L, ))
expect_equal(or3s(jyb %in% 1:4, c == 1L, ),
bor3(jyb %in% 1:4, c == 1L, ))
expect_equal(or3s(jyc %in% 1:4, c == 9L, ),
bor3(jyc %in% 1:4, c == 9L, ))
expect_equal(or3s(jyd %in% 1:4, b == 0L, logi_p),
bor3(jyd %in% 1:4, b == 0L, logi_p))
expect_equal(or3s(jye %in% 1:4, q == 1L, logi_k),
bor3(jye %in% 1:4, q == 1L, logi_k))
expect_equal(or3s(jyf %in% 1:4, e == 9L, logi_u),
bor3(jyf %in% 1:4, e == 9L, logi_u))
expect_equal(or3s(jyg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jyg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jyh %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jyh %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jyi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(jyi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(jyj %in% c(4L, -3L, 2L, 7L, 8L), , !logi_b),
bor3(jyj %in% c(4L, -3L, 2L, 7L, 8L), , !logi_b))
expect_equal(or3s(jyk %in% c(4L, -3L, 2L, 7L, 8L), , !logi_c),
bor3(jyk %in% c(4L, -3L, 2L, 7L, 8L), , !logi_c))
expect_equal(or3s(jyl %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a),
bor3(jyl %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a))
expect_equal(or3s(jym %in% c(4L, -3L, 2L, 7L, 8L), e == 0L, ),
bor3(jym %in% c(4L, -3L, 2L, 7L, 8L), e == 0L, ))
expect_equal(or3s(jyn %in% c(4L, -3L, 2L, 7L, 8L), x == 1L, ),
bor3(jyn %in% c(4L, -3L, 2L, 7L, 8L), x == 1L, ))
expect_equal(or3s(jyo %in% c(4L, -3L, 2L, 7L, 8L), n == 9L, ),
bor3(jyo %in% c(4L, -3L, 2L, 7L, 8L), n == 9L, ))
expect_equal(or3s(jyp %in% c(4L, -3L, 2L, 7L, 8L), e == 0L, !logi_c),
bor3(jyp %in% c(4L, -3L, 2L, 7L, 8L), e == 0L, !logi_c))
expect_equal(or3s(jyq %in% c(4L, -3L, 2L, 7L, 8L), k == 1L, !logi_x),
bor3(jyq %in% c(4L, -3L, 2L, 7L, 8L), k == 1L, !logi_x))
expect_equal(or3s(jyr %in% c(4L, -3L, 2L, 7L, 8L), n == 9L, !logi_v),
bor3(jyr %in% c(4L, -3L, 2L, 7L, 8L), n == 9L, !logi_v))
expect_equal(or3s(jys %in% 1:4, , ),
bor3(jys %in% 1:4, , ))
expect_equal(or3s(jyt %in% 1:4, , ),
bor3(jyt %in% 1:4, , ))
expect_equal(or3s(jyu %in% 1:4, , ),
bor3(jyu %in% 1:4, , ))
expect_equal(or3s(jyv %in% 1:4, , !logi_t),
bor3(jyv %in% 1:4, , !logi_t))
expect_equal(or3s(jyw %in% 1:4, , !logi_b),
bor3(jyw %in% 1:4, , !logi_b))
expect_equal(or3s(jyx %in% 1:4, , !logi_p),
bor3(jyx %in% 1:4, , !logi_p))
expect_equal(or3s(jyy %in% 1:4, m == 0L, ),
bor3(jyy %in% 1:4, m == 0L, ))
expect_equal(or3s(jyz %in% 1:4, f == 1L, ),
bor3(jyz %in% 1:4, f == 1L, ))
expect_equal(or3s(ka %in% 1:4, o == 9L, ),
bor3(ka %in% 1:4, o == 9L, ))
expect_equal(or3s(kb %in% 1:4, v == 0L, !logi_m),
bor3(kb %in% 1:4, v == 0L, !logi_m))
expect_equal(or3s(kc %in% 1:4, a == 1L, !logi_d),
bor3(kc %in% 1:4, a == 1L, !logi_d))
expect_equal(or3s(kd %in% 1:4, b == 9L, !logi_x),
bor3(kd %in% 1:4, b == 9L, !logi_x))
expect_equal(or3s(ke %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ke %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kh %in% c(4L, -3L, 2L, 7L, 8L), , c != 0L),
bor3(kh %in% c(4L, -3L, 2L, 7L, 8L), , c != 0L))
expect_equal(or3s(ki %in% c(4L, -3L, 2L, 7L, 8L), , k != 1L),
bor3(ki %in% c(4L, -3L, 2L, 7L, 8L), , k != 1L))
expect_equal(or3s(kj %in% c(4L, -3L, 2L, 7L, 8L), , b != 9L),
bor3(kj %in% c(4L, -3L, 2L, 7L, 8L), , b != 9L))
expect_equal(or3s(kk %in% c(4L, -3L, 2L, 7L, 8L), j == 0L, ),
bor3(kk %in% c(4L, -3L, 2L, 7L, 8L), j == 0L, ))
expect_equal(or3s(kl %in% c(4L, -3L, 2L, 7L, 8L), z == 1L, ),
bor3(kl %in% c(4L, -3L, 2L, 7L, 8L), z == 1L, ))
expect_equal(or3s(km %in% c(4L, -3L, 2L, 7L, 8L), q == 9L, ),
bor3(km %in% c(4L, -3L, 2L, 7L, 8L), q == 9L, ))
expect_equal(or3s(kn %in% c(4L, -3L, 2L, 7L, 8L), y == 0L, m != 0L),
bor3(kn %in% c(4L, -3L, 2L, 7L, 8L), y == 0L, m != 0L))
expect_equal(or3s(ko %in% c(4L, -3L, 2L, 7L, 8L), m == 1L, s != 1L),
bor3(ko %in% c(4L, -3L, 2L, 7L, 8L), m == 1L, s != 1L))
expect_equal(or3s(kp %in% c(4L, -3L, 2L, 7L, 8L), b == 9L, o != 9L),
bor3(kp %in% c(4L, -3L, 2L, 7L, 8L), b == 9L, o != 9L))
expect_equal(or3s(kq %in% 1:4, , ),
bor3(kq %in% 1:4, , ))
expect_equal(or3s(kr %in% 1:4, , ),
bor3(kr %in% 1:4, , ))
expect_equal(or3s(ks %in% 1:4, , ),
bor3(ks %in% 1:4, , ))
expect_equal(or3s(kt %in% 1:4, , g != 0L),
bor3(kt %in% 1:4, , g != 0L))
expect_equal(or3s(ku %in% 1:4, , c != 1L),
bor3(ku %in% 1:4, , c != 1L))
expect_equal(or3s(kv %in% 1:4, , v != 9L),
bor3(kv %in% 1:4, , v != 9L))
expect_equal(or3s(kw %in% 1:4, b == 0L, ),
bor3(kw %in% 1:4, b == 0L, ))
expect_equal(or3s(kx %in% 1:4, f == 1L, ),
bor3(kx %in% 1:4, f == 1L, ))
expect_equal(or3s(ky %in% 1:4, a == 9L, ),
bor3(ky %in% 1:4, a == 9L, ))
expect_equal(or3s(kz %in% 1:4, n == 0L, y != 0L),
bor3(kz %in% 1:4, n == 0L, y != 0L))
expect_equal(or3s(kaa %in% 1:4, c == 1L, h != 1L),
bor3(kaa %in% 1:4, c == 1L, h != 1L))
expect_equal(or3s(kab %in% 1:4, z == 9L, y != 9L),
bor3(kab %in% 1:4, z == 9L, y != 9L))
expect_equal(or3s(kac %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kac %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kad %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kad %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kae %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kae %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kaf %in% c(4L, -3L, 2L, 7L, 8L), , v %between% c(-1L, 1L)),
bor3(kaf %in% c(4L, -3L, 2L, 7L, 8L), , v %between% c(-1L, 1L)))
expect_equal(or3s(kag %in% c(4L, -3L, 2L, 7L, 8L), , d %between% c(-1L, 1L)),
bor3(kag %in% c(4L, -3L, 2L, 7L, 8L), , d %between% c(-1L, 1L)))
expect_equal(or3s(kah %in% c(4L, -3L, 2L, 7L, 8L), , r %between% c(-1L, 1L)),
bor3(kah %in% c(4L, -3L, 2L, 7L, 8L), , r %between% c(-1L, 1L)))
expect_equal(or3s(kai %in% c(4L, -3L, 2L, 7L, 8L), n == 0L, ),
bor3(kai %in% c(4L, -3L, 2L, 7L, 8L), n == 0L, ))
expect_equal(or3s(kaj %in% c(4L, -3L, 2L, 7L, 8L), e == 1L, ),
bor3(kaj %in% c(4L, -3L, 2L, 7L, 8L), e == 1L, ))
expect_equal(or3s(kak %in% c(4L, -3L, 2L, 7L, 8L), j == 9L, ),
bor3(kak %in% c(4L, -3L, 2L, 7L, 8L), j == 9L, ))
expect_equal(or3s(kal %in% c(4L, -3L, 2L, 7L, 8L), y == 0L, z %between% c(-1L, 1L)),
bor3(kal %in% c(4L, -3L, 2L, 7L, 8L), y == 0L, z %between% c(-1L, 1L)))
expect_equal(or3s(kam %in% c(4L, -3L, 2L, 7L, 8L), b == 1L, n %between% c(-1L, 1L)),
bor3(kam %in% c(4L, -3L, 2L, 7L, 8L), b == 1L, n %between% c(-1L, 1L)))
expect_equal(or3s(kan %in% c(4L, -3L, 2L, 7L, 8L), s == 9L, g %between% c(-1L, 1L)),
bor3(kan %in% c(4L, -3L, 2L, 7L, 8L), s == 9L, g %between% c(-1L, 1L)))
expect_equal(or3s(kao %in% 1:4, , ),
bor3(kao %in% 1:4, , ))
expect_equal(or3s(kap %in% 1:4, , ),
bor3(kap %in% 1:4, , ))
expect_equal(or3s(kaq %in% 1:4, , ),
bor3(kaq %in% 1:4, , ))
expect_equal(or3s(kar %in% 1:4, , n %between% c(-1L, 1L)),
bor3(kar %in% 1:4, , n %between% c(-1L, 1L)))
expect_equal(or3s(kas %in% 1:4, , s %between% c(-1L, 1L)),
bor3(kas %in% 1:4, , s %between% c(-1L, 1L)))
expect_equal(or3s(kat %in% 1:4, , s %between% c(-1L, 1L)),
bor3(kat %in% 1:4, , s %between% c(-1L, 1L)))
expect_equal(or3s(kau %in% 1:4, m == 0L, ),
bor3(kau %in% 1:4, m == 0L, ))
expect_equal(or3s(kav %in% 1:4, z == 1L, ),
bor3(kav %in% 1:4, z == 1L, ))
expect_equal(or3s(kaw %in% 1:4, w == 9L, ),
bor3(kaw %in% 1:4, w == 9L, ))
expect_equal(or3s(kax %in% 1:4, v == 0L, o %between% c(-1L, 1L)),
bor3(kax %in% 1:4, v == 0L, o %between% c(-1L, 1L)))
expect_equal(or3s(kay %in% 1:4, r == 1L, u %between% c(-1L, 1L)),
bor3(kay %in% 1:4, r == 1L, u %between% c(-1L, 1L)))
expect_equal(or3s(kaz %in% 1:4, z == 9L, r %between% c(-1L, 1L)),
bor3(kaz %in% 1:4, z == 9L, r %between% c(-1L, 1L)))
expect_equal(or3s(kba %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kba %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kbb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kbb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kbc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kbc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kbd %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kbd %in% c(4L, -3L, 2L, 7L, 8L), , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kbe %in% c(4L, -3L, 2L, 7L, 8L), , q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kbe %in% c(4L, -3L, 2L, 7L, 8L), , q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kbf %in% c(4L, -3L, 2L, 7L, 8L), , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kbf %in% c(4L, -3L, 2L, 7L, 8L), , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kbg %in% c(4L, -3L, 2L, 7L, 8L), o == 0L, ),
bor3(kbg %in% c(4L, -3L, 2L, 7L, 8L), o == 0L, ))
expect_equal(or3s(kbh %in% c(4L, -3L, 2L, 7L, 8L), o == 1L, ),
bor3(kbh %in% c(4L, -3L, 2L, 7L, 8L), o == 1L, ))
expect_equal(or3s(kbi %in% c(4L, -3L, 2L, 7L, 8L), h == 9L, ),
bor3(kbi %in% c(4L, -3L, 2L, 7L, 8L), h == 9L, ))
expect_equal(or3s(kbj %in% c(4L, -3L, 2L, 7L, 8L), p == 0L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kbj %in% c(4L, -3L, 2L, 7L, 8L), p == 0L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kbk %in% c(4L, -3L, 2L, 7L, 8L), e == 1L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kbk %in% c(4L, -3L, 2L, 7L, 8L), e == 1L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kbl %in% c(4L, -3L, 2L, 7L, 8L), o == 9L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kbl %in% c(4L, -3L, 2L, 7L, 8L), o == 9L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kbm %in% 1:4, , ),
bor3(kbm %in% 1:4, , ))
expect_equal(or3s(kbn %in% 1:4, , ),
bor3(kbn %in% 1:4, , ))
expect_equal(or3s(kbo %in% 1:4, , ),
bor3(kbo %in% 1:4, , ))
expect_equal(or3s(kbp %in% 1:4, , k %in% 1:4),
bor3(kbp %in% 1:4, , k %in% 1:4))
expect_equal(or3s(kbq %in% 1:4, , q %in% 1:4),
bor3(kbq %in% 1:4, , q %in% 1:4))
expect_equal(or3s(kbr %in% 1:4, , h %in% 1:4),
bor3(kbr %in% 1:4, , h %in% 1:4))
expect_equal(or3s(kbs %in% 1:4, z == 0L, ),
bor3(kbs %in% 1:4, z == 0L, ))
expect_equal(or3s(kbt %in% 1:4, p == 1L, ),
bor3(kbt %in% 1:4, p == 1L, ))
expect_equal(or3s(kbu %in% 1:4, z == 9L, ),
bor3(kbu %in% 1:4, z == 9L, ))
expect_equal(or3s(kbv %in% 1:4, f == 0L, q %in% 1:4),
bor3(kbv %in% 1:4, f == 0L, q %in% 1:4))
expect_equal(or3s(kbw %in% 1:4, z == 1L, k %in% 1:4),
bor3(kbw %in% 1:4, z == 1L, k %in% 1:4))
expect_equal(or3s(kbx %in% 1:4, p == 9L, u %in% 1:4),
bor3(kbx %in% 1:4, p == 9L, u %in% 1:4))
expect_equal(or3s(kby %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kby %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kbz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kbz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kca %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kca %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kcb %in% c(4L, -3L, 2L, 7L, 8L), , w < 0L),
bor3(kcb %in% c(4L, -3L, 2L, 7L, 8L), , w < 0L))
expect_equal(or3s(kcc %in% c(4L, -3L, 2L, 7L, 8L), , m < 1L),
bor3(kcc %in% c(4L, -3L, 2L, 7L, 8L), , m < 1L))
expect_equal(or3s(kcd %in% c(4L, -3L, 2L, 7L, 8L), , p < 9L),
bor3(kcd %in% c(4L, -3L, 2L, 7L, 8L), , p < 9L))
expect_equal(or3s(kce %in% c(4L, -3L, 2L, 7L, 8L), d == 0L, ),
bor3(kce %in% c(4L, -3L, 2L, 7L, 8L), d == 0L, ))
expect_equal(or3s(kcf %in% c(4L, -3L, 2L, 7L, 8L), m == 1L, ),
bor3(kcf %in% c(4L, -3L, 2L, 7L, 8L), m == 1L, ))
expect_equal(or3s(kcg %in% c(4L, -3L, 2L, 7L, 8L), b == 9L, ),
bor3(kcg %in% c(4L, -3L, 2L, 7L, 8L), b == 9L, ))
expect_equal(or3s(kch %in% c(4L, -3L, 2L, 7L, 8L), h == 0L, h < 0L),
bor3(kch %in% c(4L, -3L, 2L, 7L, 8L), h == 0L, h < 0L))
expect_equal(or3s(kci %in% c(4L, -3L, 2L, 7L, 8L), k == 1L, o < 1L),
bor3(kci %in% c(4L, -3L, 2L, 7L, 8L), k == 1L, o < 1L))
expect_equal(or3s(kcj %in% c(4L, -3L, 2L, 7L, 8L), n == 9L, y < 9L),
bor3(kcj %in% c(4L, -3L, 2L, 7L, 8L), n == 9L, y < 9L))
expect_equal(or3s(kck %in% 1:4, , ),
bor3(kck %in% 1:4, , ))
expect_equal(or3s(kcl %in% 1:4, , ),
bor3(kcl %in% 1:4, , ))
expect_equal(or3s(kcm %in% 1:4, , ),
bor3(kcm %in% 1:4, , ))
expect_equal(or3s(kcn %in% 1:4, , n < 0L),
bor3(kcn %in% 1:4, , n < 0L))
expect_equal(or3s(kco %in% 1:4, , f < 1L),
bor3(kco %in% 1:4, , f < 1L))
expect_equal(or3s(kcp %in% 1:4, , b < 9L),
bor3(kcp %in% 1:4, , b < 9L))
expect_equal(or3s(kcq %in% 1:4, r == 0L, ),
bor3(kcq %in% 1:4, r == 0L, ))
expect_equal(or3s(kcr %in% 1:4, v == 1L, ),
bor3(kcr %in% 1:4, v == 1L, ))
expect_equal(or3s(kcs %in% 1:4, m == 9L, ),
bor3(kcs %in% 1:4, m == 9L, ))
expect_equal(or3s(kct %in% 1:4, u == 0L, a < 0L),
bor3(kct %in% 1:4, u == 0L, a < 0L))
expect_equal(or3s(kcu %in% 1:4, d == 1L, s < 1L),
bor3(kcu %in% 1:4, d == 1L, s < 1L))
expect_equal(or3s(kcv %in% 1:4, w == 9L, s < 9L),
bor3(kcv %in% 1:4, w == 9L, s < 9L))
expect_equal(or3s(kcw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kcw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kcx %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kcx %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kcy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kcy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kcz %in% c(4L, -3L, 2L, 7L, 8L), , w <= 0L),
bor3(kcz %in% c(4L, -3L, 2L, 7L, 8L), , w <= 0L))
expect_equal(or3s(kda %in% c(4L, -3L, 2L, 7L, 8L), , d <= 1L),
bor3(kda %in% c(4L, -3L, 2L, 7L, 8L), , d <= 1L))
expect_equal(or3s(kdb %in% c(4L, -3L, 2L, 7L, 8L), , b <= 9L),
bor3(kdb %in% c(4L, -3L, 2L, 7L, 8L), , b <= 9L))
expect_equal(or3s(kdc %in% c(4L, -3L, 2L, 7L, 8L), x == 0L, ),
bor3(kdc %in% c(4L, -3L, 2L, 7L, 8L), x == 0L, ))
expect_equal(or3s(kdd %in% c(4L, -3L, 2L, 7L, 8L), g == 1L, ),
bor3(kdd %in% c(4L, -3L, 2L, 7L, 8L), g == 1L, ))
expect_equal(or3s(kde %in% c(4L, -3L, 2L, 7L, 8L), h == 9L, ),
bor3(kde %in% c(4L, -3L, 2L, 7L, 8L), h == 9L, ))
expect_equal(or3s(kdf %in% c(4L, -3L, 2L, 7L, 8L), s == 0L, r <= 0L),
bor3(kdf %in% c(4L, -3L, 2L, 7L, 8L), s == 0L, r <= 0L))
expect_equal(or3s(kdg %in% c(4L, -3L, 2L, 7L, 8L), h == 1L, i <= 1L),
bor3(kdg %in% c(4L, -3L, 2L, 7L, 8L), h == 1L, i <= 1L))
expect_equal(or3s(kdh %in% c(4L, -3L, 2L, 7L, 8L), z == 9L, e <= 9L),
bor3(kdh %in% c(4L, -3L, 2L, 7L, 8L), z == 9L, e <= 9L))
expect_equal(or3s(kdi %in% 1:4, , ),
bor3(kdi %in% 1:4, , ))
expect_equal(or3s(kdj %in% 1:4, , ),
bor3(kdj %in% 1:4, , ))
expect_equal(or3s(kdk %in% 1:4, , ),
bor3(kdk %in% 1:4, , ))
expect_equal(or3s(kdl %in% 1:4, , r <= 0L),
bor3(kdl %in% 1:4, , r <= 0L))
expect_equal(or3s(kdm %in% 1:4, , l <= 1L),
bor3(kdm %in% 1:4, , l <= 1L))
expect_equal(or3s(kdn %in% 1:4, , m <= 9L),
bor3(kdn %in% 1:4, , m <= 9L))
expect_equal(or3s(kdo %in% 1:4, z == 0L, ),
bor3(kdo %in% 1:4, z == 0L, ))
expect_equal(or3s(kdp %in% 1:4, s == 1L, ),
bor3(kdp %in% 1:4, s == 1L, ))
expect_equal(or3s(kdq %in% 1:4, r == 9L, ),
bor3(kdq %in% 1:4, r == 9L, ))
expect_equal(or3s(kdr %in% 1:4, m == 0L, s <= 0L),
bor3(kdr %in% 1:4, m == 0L, s <= 0L))
expect_equal(or3s(kds %in% 1:4, d == 1L, w <= 1L),
bor3(kds %in% 1:4, d == 1L, w <= 1L))
expect_equal(or3s(kdt %in% 1:4, k == 9L, q <= 9L),
bor3(kdt %in% 1:4, k == 9L, q <= 9L))
expect_equal(or3s(kdu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kdu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kdv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kdv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kdw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kdw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kdx %in% c(4L, -3L, 2L, 7L, 8L), , k == 0L),
bor3(kdx %in% c(4L, -3L, 2L, 7L, 8L), , k == 0L))
expect_equal(or3s(kdy %in% c(4L, -3L, 2L, 7L, 8L), , q == 1L),
bor3(kdy %in% c(4L, -3L, 2L, 7L, 8L), , q == 1L))
expect_equal(or3s(kdz %in% c(4L, -3L, 2L, 7L, 8L), , o == 9L),
bor3(kdz %in% c(4L, -3L, 2L, 7L, 8L), , o == 9L))
expect_equal(or3s(kea %in% c(4L, -3L, 2L, 7L, 8L), c == 0L, ),
bor3(kea %in% c(4L, -3L, 2L, 7L, 8L), c == 0L, ))
expect_equal(or3s(keb %in% c(4L, -3L, 2L, 7L, 8L), g == 1L, ),
bor3(keb %in% c(4L, -3L, 2L, 7L, 8L), g == 1L, ))
expect_equal(or3s(kec %in% c(4L, -3L, 2L, 7L, 8L), q == 9L, ),
bor3(kec %in% c(4L, -3L, 2L, 7L, 8L), q == 9L, ))
expect_equal(or3s(ked %in% c(4L, -3L, 2L, 7L, 8L), q == 0L, x == 0L),
bor3(ked %in% c(4L, -3L, 2L, 7L, 8L), q == 0L, x == 0L))
expect_equal(or3s(kee %in% c(4L, -3L, 2L, 7L, 8L), j == 1L, j == 1L),
bor3(kee %in% c(4L, -3L, 2L, 7L, 8L), j == 1L, j == 1L))
expect_equal(or3s(kef %in% c(4L, -3L, 2L, 7L, 8L), f == 9L, p == 9L),
bor3(kef %in% c(4L, -3L, 2L, 7L, 8L), f == 9L, p == 9L))
expect_equal(or3s(keg %in% 1:4, , ),
bor3(keg %in% 1:4, , ))
expect_equal(or3s(keh %in% 1:4, , ),
bor3(keh %in% 1:4, , ))
expect_equal(or3s(kei %in% 1:4, , ),
bor3(kei %in% 1:4, , ))
expect_equal(or3s(kej %in% 1:4, , w == 0L),
bor3(kej %in% 1:4, , w == 0L))
expect_equal(or3s(kek %in% 1:4, , l == 1L),
bor3(kek %in% 1:4, , l == 1L))
expect_equal(or3s(kel %in% 1:4, , l == 9L),
bor3(kel %in% 1:4, , l == 9L))
expect_equal(or3s(kem %in% 1:4, o == 0L, ),
bor3(kem %in% 1:4, o == 0L, ))
expect_equal(or3s(ken %in% 1:4, o == 1L, ),
bor3(ken %in% 1:4, o == 1L, ))
expect_equal(or3s(keo %in% 1:4, y == 9L, ),
bor3(keo %in% 1:4, y == 9L, ))
expect_equal(or3s(kep %in% 1:4, d == 0L, o == 0L),
bor3(kep %in% 1:4, d == 0L, o == 0L))
expect_equal(or3s(keq %in% 1:4, x == 1L, i == 1L),
bor3(keq %in% 1:4, x == 1L, i == 1L))
expect_equal(or3s(ker %in% 1:4, m == 9L, r == 9L),
bor3(ker %in% 1:4, m == 9L, r == 9L))
expect_equal(or3s(kes %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kes %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ket %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ket %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(keu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(keu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kev %in% c(4L, -3L, 2L, 7L, 8L), , p > 0L),
bor3(kev %in% c(4L, -3L, 2L, 7L, 8L), , p > 0L))
expect_equal(or3s(kew %in% c(4L, -3L, 2L, 7L, 8L), , y > 1L),
bor3(kew %in% c(4L, -3L, 2L, 7L, 8L), , y > 1L))
expect_equal(or3s(kex %in% c(4L, -3L, 2L, 7L, 8L), , e > 9L),
bor3(kex %in% c(4L, -3L, 2L, 7L, 8L), , e > 9L))
expect_equal(or3s(key %in% c(4L, -3L, 2L, 7L, 8L), l == 0L, ),
bor3(key %in% c(4L, -3L, 2L, 7L, 8L), l == 0L, ))
expect_equal(or3s(kez %in% c(4L, -3L, 2L, 7L, 8L), a == 1L, ),
bor3(kez %in% c(4L, -3L, 2L, 7L, 8L), a == 1L, ))
expect_equal(or3s(kfa %in% c(4L, -3L, 2L, 7L, 8L), s == 9L, ),
bor3(kfa %in% c(4L, -3L, 2L, 7L, 8L), s == 9L, ))
expect_equal(or3s(kfb %in% c(4L, -3L, 2L, 7L, 8L), s == 0L, n > 0L),
bor3(kfb %in% c(4L, -3L, 2L, 7L, 8L), s == 0L, n > 0L))
expect_equal(or3s(kfc %in% c(4L, -3L, 2L, 7L, 8L), r == 1L, v > 1L),
bor3(kfc %in% c(4L, -3L, 2L, 7L, 8L), r == 1L, v > 1L))
expect_equal(or3s(kfd %in% c(4L, -3L, 2L, 7L, 8L), p == 9L, c > 9L),
bor3(kfd %in% c(4L, -3L, 2L, 7L, 8L), p == 9L, c > 9L))
expect_equal(or3s(kfe %in% 1:4, , ),
bor3(kfe %in% 1:4, , ))
expect_equal(or3s(kff %in% 1:4, , ),
bor3(kff %in% 1:4, , ))
expect_equal(or3s(kfg %in% 1:4, , ),
bor3(kfg %in% 1:4, , ))
expect_equal(or3s(kfh %in% 1:4, , z > 0L),
bor3(kfh %in% 1:4, , z > 0L))
expect_equal(or3s(kfi %in% 1:4, , w > 1L),
bor3(kfi %in% 1:4, , w > 1L))
expect_equal(or3s(kfj %in% 1:4, , c > 9L),
bor3(kfj %in% 1:4, , c > 9L))
expect_equal(or3s(kfk %in% 1:4, t == 0L, ),
bor3(kfk %in% 1:4, t == 0L, ))
expect_equal(or3s(kfl %in% 1:4, h == 1L, ),
bor3(kfl %in% 1:4, h == 1L, ))
expect_equal(or3s(kfm %in% 1:4, a == 9L, ),
bor3(kfm %in% 1:4, a == 9L, ))
expect_equal(or3s(kfn %in% 1:4, o == 0L, g > 0L),
bor3(kfn %in% 1:4, o == 0L, g > 0L))
expect_equal(or3s(kfo %in% 1:4, q == 1L, p > 1L),
bor3(kfo %in% 1:4, q == 1L, p > 1L))
expect_equal(or3s(kfp %in% 1:4, e == 9L, d > 9L),
bor3(kfp %in% 1:4, e == 9L, d > 9L))
expect_equal(or3s(kfq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kfq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kfr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kfr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kfs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kfs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kft %in% c(4L, -3L, 2L, 7L, 8L), , d >= 0L),
bor3(kft %in% c(4L, -3L, 2L, 7L, 8L), , d >= 0L))
expect_equal(or3s(kfu %in% c(4L, -3L, 2L, 7L, 8L), , p >= 1L),
bor3(kfu %in% c(4L, -3L, 2L, 7L, 8L), , p >= 1L))
expect_equal(or3s(kfv %in% c(4L, -3L, 2L, 7L, 8L), , v >= 9L),
bor3(kfv %in% c(4L, -3L, 2L, 7L, 8L), , v >= 9L))
expect_equal(or3s(kfw %in% c(4L, -3L, 2L, 7L, 8L), w == 0L, ),
bor3(kfw %in% c(4L, -3L, 2L, 7L, 8L), w == 0L, ))
expect_equal(or3s(kfx %in% c(4L, -3L, 2L, 7L, 8L), r == 1L, ),
bor3(kfx %in% c(4L, -3L, 2L, 7L, 8L), r == 1L, ))
expect_equal(or3s(kfy %in% c(4L, -3L, 2L, 7L, 8L), h == 9L, ),
bor3(kfy %in% c(4L, -3L, 2L, 7L, 8L), h == 9L, ))
expect_equal(or3s(kfz %in% c(4L, -3L, 2L, 7L, 8L), n == 0L, a >= 0L),
bor3(kfz %in% c(4L, -3L, 2L, 7L, 8L), n == 0L, a >= 0L))
expect_equal(or3s(kga %in% c(4L, -3L, 2L, 7L, 8L), u == 1L, a >= 1L),
bor3(kga %in% c(4L, -3L, 2L, 7L, 8L), u == 1L, a >= 1L))
expect_equal(or3s(kgb %in% c(4L, -3L, 2L, 7L, 8L), z == 9L, j >= 9L),
bor3(kgb %in% c(4L, -3L, 2L, 7L, 8L), z == 9L, j >= 9L))
expect_equal(or3s(kgc %in% 1:4, , ),
bor3(kgc %in% 1:4, , ))
expect_equal(or3s(kgd %in% 1:4, , ),
bor3(kgd %in% 1:4, , ))
expect_equal(or3s(kge %in% 1:4, , ),
bor3(kge %in% 1:4, , ))
expect_equal(or3s(kgf %in% 1:4, , a >= 0L),
bor3(kgf %in% 1:4, , a >= 0L))
expect_equal(or3s(kgg %in% 1:4, , d >= 1L),
bor3(kgg %in% 1:4, , d >= 1L))
expect_equal(or3s(kgh %in% 1:4, , l >= 9L),
bor3(kgh %in% 1:4, , l >= 9L))
expect_equal(or3s(kgi %in% 1:4, a == 0L, ),
bor3(kgi %in% 1:4, a == 0L, ))
expect_equal(or3s(kgj %in% 1:4, t == 1L, ),
bor3(kgj %in% 1:4, t == 1L, ))
expect_equal(or3s(kgk %in% 1:4, p == 9L, ),
bor3(kgk %in% 1:4, p == 9L, ))
expect_equal(or3s(kgl %in% 1:4, c == 0L, l >= 0L),
bor3(kgl %in% 1:4, c == 0L, l >= 0L))
expect_equal(or3s(kgm %in% 1:4, v == 1L, r >= 1L),
bor3(kgm %in% 1:4, v == 1L, r >= 1L))
expect_equal(or3s(kgn %in% 1:4, y == 9L, b >= 9L),
bor3(kgn %in% 1:4, y == 9L, b >= 9L))
expect_equal(or3s(kgo %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kgo %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kgp %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kgp %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kgq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kgq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kgr %in% c(4L, -3L, 2L, 7L, 8L), , logi_e),
bor3(kgr %in% c(4L, -3L, 2L, 7L, 8L), , logi_e))
expect_equal(or3s(kgs %in% c(4L, -3L, 2L, 7L, 8L), , logi_p),
bor3(kgs %in% c(4L, -3L, 2L, 7L, 8L), , logi_p))
expect_equal(or3s(kgt %in% c(4L, -3L, 2L, 7L, 8L), , logi_n),
bor3(kgt %in% c(4L, -3L, 2L, 7L, 8L), , logi_n))
expect_equal(or3s(kgu %in% c(4L, -3L, 2L, 7L, 8L), v > 0L, ),
bor3(kgu %in% c(4L, -3L, 2L, 7L, 8L), v > 0L, ))
expect_equal(or3s(kgv %in% c(4L, -3L, 2L, 7L, 8L), u > 1L, ),
bor3(kgv %in% c(4L, -3L, 2L, 7L, 8L), u > 1L, ))
expect_equal(or3s(kgw %in% c(4L, -3L, 2L, 7L, 8L), i > 9L, ),
bor3(kgw %in% c(4L, -3L, 2L, 7L, 8L), i > 9L, ))
expect_equal(or3s(kgx %in% c(4L, -3L, 2L, 7L, 8L), u > 0L, logi_y),
bor3(kgx %in% c(4L, -3L, 2L, 7L, 8L), u > 0L, logi_y))
expect_equal(or3s(kgy %in% c(4L, -3L, 2L, 7L, 8L), s > 1L, logi_w),
bor3(kgy %in% c(4L, -3L, 2L, 7L, 8L), s > 1L, logi_w))
expect_equal(or3s(kgz %in% c(4L, -3L, 2L, 7L, 8L), w > 9L, logi_c),
bor3(kgz %in% c(4L, -3L, 2L, 7L, 8L), w > 9L, logi_c))
expect_equal(or3s(kha %in% 1:4, , ),
bor3(kha %in% 1:4, , ))
expect_equal(or3s(khb %in% 1:4, , ),
bor3(khb %in% 1:4, , ))
expect_equal(or3s(khc %in% 1:4, , ),
bor3(khc %in% 1:4, , ))
expect_equal(or3s(khd %in% 1:4, , logi_k),
bor3(khd %in% 1:4, , logi_k))
expect_equal(or3s(khe %in% 1:4, , logi_q),
bor3(khe %in% 1:4, , logi_q))
expect_equal(or3s(khf %in% 1:4, , logi_o),
bor3(khf %in% 1:4, , logi_o))
expect_equal(or3s(khg %in% 1:4, v > 0L, ),
bor3(khg %in% 1:4, v > 0L, ))
expect_equal(or3s(khh %in% 1:4, t > 1L, ),
bor3(khh %in% 1:4, t > 1L, ))
expect_equal(or3s(khi %in% 1:4, r > 9L, ),
bor3(khi %in% 1:4, r > 9L, ))
expect_equal(or3s(khj %in% 1:4, h > 0L, logi_w),
bor3(khj %in% 1:4, h > 0L, logi_w))
expect_equal(or3s(khk %in% 1:4, t > 1L, logi_k),
bor3(khk %in% 1:4, t > 1L, logi_k))
expect_equal(or3s(khl %in% 1:4, x > 9L, logi_i),
bor3(khl %in% 1:4, x > 9L, logi_i))
expect_equal(or3s(khm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(khm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(khn %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(khn %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kho %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kho %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(khp %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a),
bor3(khp %in% c(4L, -3L, 2L, 7L, 8L), , !logi_a))
expect_equal(or3s(khq %in% c(4L, -3L, 2L, 7L, 8L), , !logi_h),
bor3(khq %in% c(4L, -3L, 2L, 7L, 8L), , !logi_h))
expect_equal(or3s(khr %in% c(4L, -3L, 2L, 7L, 8L), , !logi_f),
bor3(khr %in% c(4L, -3L, 2L, 7L, 8L), , !logi_f))
expect_equal(or3s(khs %in% c(4L, -3L, 2L, 7L, 8L), c > 0L, ),
bor3(khs %in% c(4L, -3L, 2L, 7L, 8L), c > 0L, ))
expect_equal(or3s(kht %in% c(4L, -3L, 2L, 7L, 8L), m > 1L, ),
bor3(kht %in% c(4L, -3L, 2L, 7L, 8L), m > 1L, ))
expect_equal(or3s(khu %in% c(4L, -3L, 2L, 7L, 8L), o > 9L, ),
bor3(khu %in% c(4L, -3L, 2L, 7L, 8L), o > 9L, ))
expect_equal(or3s(khv %in% c(4L, -3L, 2L, 7L, 8L), t > 0L, !logi_b),
bor3(khv %in% c(4L, -3L, 2L, 7L, 8L), t > 0L, !logi_b))
expect_equal(or3s(khw %in% c(4L, -3L, 2L, 7L, 8L), v > 1L, !logi_j),
bor3(khw %in% c(4L, -3L, 2L, 7L, 8L), v > 1L, !logi_j))
expect_equal(or3s(khx %in% c(4L, -3L, 2L, 7L, 8L), w > 9L, !logi_j),
bor3(khx %in% c(4L, -3L, 2L, 7L, 8L), w > 9L, !logi_j))
expect_equal(or3s(khy %in% 1:4, , ),
bor3(khy %in% 1:4, , ))
expect_equal(or3s(khz %in% 1:4, , ),
bor3(khz %in% 1:4, , ))
expect_equal(or3s(kia %in% 1:4, , ),
bor3(kia %in% 1:4, , ))
expect_equal(or3s(kib %in% 1:4, , !logi_i),
bor3(kib %in% 1:4, , !logi_i))
expect_equal(or3s(kic %in% 1:4, , !logi_p),
bor3(kic %in% 1:4, , !logi_p))
expect_equal(or3s(kid %in% 1:4, , !logi_v),
bor3(kid %in% 1:4, , !logi_v))
expect_equal(or3s(kie %in% 1:4, o > 0L, ),
bor3(kie %in% 1:4, o > 0L, ))
expect_equal(or3s(kif %in% 1:4, c > 1L, ),
bor3(kif %in% 1:4, c > 1L, ))
expect_equal(or3s(kig %in% 1:4, q > 9L, ),
bor3(kig %in% 1:4, q > 9L, ))
expect_equal(or3s(kih %in% 1:4, v > 0L, !logi_t),
bor3(kih %in% 1:4, v > 0L, !logi_t))
expect_equal(or3s(kii %in% 1:4, p > 1L, !logi_g),
bor3(kii %in% 1:4, p > 1L, !logi_g))
expect_equal(or3s(kij %in% 1:4, r > 9L, !logi_k),
bor3(kij %in% 1:4, r > 9L, !logi_k))
expect_equal(or3s(kik %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kik %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kil %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kil %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kim %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kim %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kin %in% c(4L, -3L, 2L, 7L, 8L), , g != 0L),
bor3(kin %in% c(4L, -3L, 2L, 7L, 8L), , g != 0L))
expect_equal(or3s(kio %in% c(4L, -3L, 2L, 7L, 8L), , h != 1L),
bor3(kio %in% c(4L, -3L, 2L, 7L, 8L), , h != 1L))
expect_equal(or3s(kip %in% c(4L, -3L, 2L, 7L, 8L), , q != 9L),
bor3(kip %in% c(4L, -3L, 2L, 7L, 8L), , q != 9L))
expect_equal(or3s(kiq %in% c(4L, -3L, 2L, 7L, 8L), m > 0L, ),
bor3(kiq %in% c(4L, -3L, 2L, 7L, 8L), m > 0L, ))
expect_equal(or3s(kir %in% c(4L, -3L, 2L, 7L, 8L), y > 1L, ),
bor3(kir %in% c(4L, -3L, 2L, 7L, 8L), y > 1L, ))
expect_equal(or3s(kis %in% c(4L, -3L, 2L, 7L, 8L), k > 9L, ),
bor3(kis %in% c(4L, -3L, 2L, 7L, 8L), k > 9L, ))
expect_equal(or3s(kit %in% c(4L, -3L, 2L, 7L, 8L), p > 0L, d != 0L),
bor3(kit %in% c(4L, -3L, 2L, 7L, 8L), p > 0L, d != 0L))
expect_equal(or3s(kiu %in% c(4L, -3L, 2L, 7L, 8L), l > 1L, x != 1L),
bor3(kiu %in% c(4L, -3L, 2L, 7L, 8L), l > 1L, x != 1L))
expect_equal(or3s(kiv %in% c(4L, -3L, 2L, 7L, 8L), s > 9L, d != 9L),
bor3(kiv %in% c(4L, -3L, 2L, 7L, 8L), s > 9L, d != 9L))
expect_equal(or3s(kiw %in% 1:4, , ),
bor3(kiw %in% 1:4, , ))
expect_equal(or3s(kix %in% 1:4, , ),
bor3(kix %in% 1:4, , ))
expect_equal(or3s(kiy %in% 1:4, , ),
bor3(kiy %in% 1:4, , ))
expect_equal(or3s(kiz %in% 1:4, , z != 0L),
bor3(kiz %in% 1:4, , z != 0L))
expect_equal(or3s(kja %in% 1:4, , n != 1L),
bor3(kja %in% 1:4, , n != 1L))
expect_equal(or3s(kjb %in% 1:4, , b != 9L),
bor3(kjb %in% 1:4, , b != 9L))
expect_equal(or3s(kjc %in% 1:4, b > 0L, ),
bor3(kjc %in% 1:4, b > 0L, ))
expect_equal(or3s(kjd %in% 1:4, j > 1L, ),
bor3(kjd %in% 1:4, j > 1L, ))
expect_equal(or3s(kje %in% 1:4, j > 9L, ),
bor3(kje %in% 1:4, j > 9L, ))
expect_equal(or3s(kjf %in% 1:4, y > 0L, k != 0L),
bor3(kjf %in% 1:4, y > 0L, k != 0L))
expect_equal(or3s(kjg %in% 1:4, n > 1L, m != 1L),
bor3(kjg %in% 1:4, n > 1L, m != 1L))
expect_equal(or3s(kjh %in% 1:4, u > 9L, q != 9L),
bor3(kjh %in% 1:4, u > 9L, q != 9L))
expect_equal(or3s(kji %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kji %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kjj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kjj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kjk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kjk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kjl %in% c(4L, -3L, 2L, 7L, 8L), , y %between% c(-1L, 1L)),
bor3(kjl %in% c(4L, -3L, 2L, 7L, 8L), , y %between% c(-1L, 1L)))
expect_equal(or3s(kjm %in% c(4L, -3L, 2L, 7L, 8L), , a %between% c(-1L, 1L)),
bor3(kjm %in% c(4L, -3L, 2L, 7L, 8L), , a %between% c(-1L, 1L)))
expect_equal(or3s(kjn %in% c(4L, -3L, 2L, 7L, 8L), , c %between% c(-1L, 1L)),
bor3(kjn %in% c(4L, -3L, 2L, 7L, 8L), , c %between% c(-1L, 1L)))
expect_equal(or3s(kjo %in% c(4L, -3L, 2L, 7L, 8L), v > 0L, ),
bor3(kjo %in% c(4L, -3L, 2L, 7L, 8L), v > 0L, ))
expect_equal(or3s(kjp %in% c(4L, -3L, 2L, 7L, 8L), z > 1L, ),
bor3(kjp %in% c(4L, -3L, 2L, 7L, 8L), z > 1L, ))
expect_equal(or3s(kjq %in% c(4L, -3L, 2L, 7L, 8L), k > 9L, ),
bor3(kjq %in% c(4L, -3L, 2L, 7L, 8L), k > 9L, ))
expect_equal(or3s(kjr %in% c(4L, -3L, 2L, 7L, 8L), g > 0L, u %between% c(-1L, 1L)),
bor3(kjr %in% c(4L, -3L, 2L, 7L, 8L), g > 0L, u %between% c(-1L, 1L)))
expect_equal(or3s(kjs %in% c(4L, -3L, 2L, 7L, 8L), w > 1L, s %between% c(-1L, 1L)),
bor3(kjs %in% c(4L, -3L, 2L, 7L, 8L), w > 1L, s %between% c(-1L, 1L)))
expect_equal(or3s(kjt %in% c(4L, -3L, 2L, 7L, 8L), x > 9L, w %between% c(-1L, 1L)),
bor3(kjt %in% c(4L, -3L, 2L, 7L, 8L), x > 9L, w %between% c(-1L, 1L)))
expect_equal(or3s(kju %in% 1:4, , ),
bor3(kju %in% 1:4, , ))
expect_equal(or3s(kjv %in% 1:4, , ),
bor3(kjv %in% 1:4, , ))
expect_equal(or3s(kjw %in% 1:4, , ),
bor3(kjw %in% 1:4, , ))
expect_equal(or3s(kjx %in% 1:4, , g %between% c(-1L, 1L)),
bor3(kjx %in% 1:4, , g %between% c(-1L, 1L)))
expect_equal(or3s(kjy %in% 1:4, , e %between% c(-1L, 1L)),
bor3(kjy %in% 1:4, , e %between% c(-1L, 1L)))
expect_equal(or3s(kjz %in% 1:4, , l %between% c(-1L, 1L)),
bor3(kjz %in% 1:4, , l %between% c(-1L, 1L)))
expect_equal(or3s(kka %in% 1:4, k > 0L, ),
bor3(kka %in% 1:4, k > 0L, ))
expect_equal(or3s(kkb %in% 1:4, u > 1L, ),
bor3(kkb %in% 1:4, u > 1L, ))
expect_equal(or3s(kkc %in% 1:4, p > 9L, ),
bor3(kkc %in% 1:4, p > 9L, ))
expect_equal(or3s(kkd %in% 1:4, v > 0L, g %between% c(-1L, 1L)),
bor3(kkd %in% 1:4, v > 0L, g %between% c(-1L, 1L)))
expect_equal(or3s(kke %in% 1:4, d > 1L, i %between% c(-1L, 1L)),
bor3(kke %in% 1:4, d > 1L, i %between% c(-1L, 1L)))
expect_equal(or3s(kkf %in% 1:4, i > 9L, u %between% c(-1L, 1L)),
bor3(kkf %in% 1:4, i > 9L, u %between% c(-1L, 1L)))
expect_equal(or3s(kkg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kkg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kkh %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kkh %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kki %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kki %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kkj %in% c(4L, -3L, 2L, 7L, 8L), , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kkj %in% c(4L, -3L, 2L, 7L, 8L), , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kkk %in% c(4L, -3L, 2L, 7L, 8L), , r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kkk %in% c(4L, -3L, 2L, 7L, 8L), , r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kkl %in% c(4L, -3L, 2L, 7L, 8L), , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kkl %in% c(4L, -3L, 2L, 7L, 8L), , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kkm %in% c(4L, -3L, 2L, 7L, 8L), b > 0L, ),
bor3(kkm %in% c(4L, -3L, 2L, 7L, 8L), b > 0L, ))
expect_equal(or3s(kkn %in% c(4L, -3L, 2L, 7L, 8L), r > 1L, ),
bor3(kkn %in% c(4L, -3L, 2L, 7L, 8L), r > 1L, ))
expect_equal(or3s(kko %in% c(4L, -3L, 2L, 7L, 8L), l > 9L, ),
bor3(kko %in% c(4L, -3L, 2L, 7L, 8L), l > 9L, ))
expect_equal(or3s(kkp %in% c(4L, -3L, 2L, 7L, 8L), o > 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kkp %in% c(4L, -3L, 2L, 7L, 8L), o > 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kkq %in% c(4L, -3L, 2L, 7L, 8L), v > 1L, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kkq %in% c(4L, -3L, 2L, 7L, 8L), v > 1L, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kkr %in% c(4L, -3L, 2L, 7L, 8L), o > 9L, o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(kkr %in% c(4L, -3L, 2L, 7L, 8L), o > 9L, o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kks %in% 1:4, , ),
bor3(kks %in% 1:4, , ))
expect_equal(or3s(kkt %in% 1:4, , ),
bor3(kkt %in% 1:4, , ))
expect_equal(or3s(kku %in% 1:4, , ),
bor3(kku %in% 1:4, , ))
expect_equal(or3s(kkv %in% 1:4, , l %in% 1:4),
bor3(kkv %in% 1:4, , l %in% 1:4))
expect_equal(or3s(kkw %in% 1:4, , k %in% 1:4),
bor3(kkw %in% 1:4, , k %in% 1:4))
expect_equal(or3s(kkx %in% 1:4, , s %in% 1:4),
bor3(kkx %in% 1:4, , s %in% 1:4))
expect_equal(or3s(kky %in% 1:4, i > 0L, ),
bor3(kky %in% 1:4, i > 0L, ))
expect_equal(or3s(kkz %in% 1:4, y > 1L, ),
bor3(kkz %in% 1:4, y > 1L, ))
expect_equal(or3s(kla %in% 1:4, c > 9L, ),
bor3(kla %in% 1:4, c > 9L, ))
expect_equal(or3s(klb %in% 1:4, v > 0L, s %in% 1:4),
bor3(klb %in% 1:4, v > 0L, s %in% 1:4))
expect_equal(or3s(klc %in% 1:4, v > 1L, r %in% 1:4),
bor3(klc %in% 1:4, v > 1L, r %in% 1:4))
expect_equal(or3s(kld %in% 1:4, u > 9L, b %in% 1:4),
bor3(kld %in% 1:4, u > 9L, b %in% 1:4))
expect_equal(or3s(kle %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kle %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(klf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(klf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(klg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(klg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(klh %in% c(4L, -3L, 2L, 7L, 8L), , f < 0L),
bor3(klh %in% c(4L, -3L, 2L, 7L, 8L), , f < 0L))
expect_equal(or3s(kli %in% c(4L, -3L, 2L, 7L, 8L), , x < 1L),
bor3(kli %in% c(4L, -3L, 2L, 7L, 8L), , x < 1L))
expect_equal(or3s(klj %in% c(4L, -3L, 2L, 7L, 8L), , g < 9L),
bor3(klj %in% c(4L, -3L, 2L, 7L, 8L), , g < 9L))
expect_equal(or3s(klk %in% c(4L, -3L, 2L, 7L, 8L), z > 0L, ),
bor3(klk %in% c(4L, -3L, 2L, 7L, 8L), z > 0L, ))
expect_equal(or3s(kll %in% c(4L, -3L, 2L, 7L, 8L), a > 1L, ),
bor3(kll %in% c(4L, -3L, 2L, 7L, 8L), a > 1L, ))
expect_equal(or3s(klm %in% c(4L, -3L, 2L, 7L, 8L), t > 9L, ),
bor3(klm %in% c(4L, -3L, 2L, 7L, 8L), t > 9L, ))
expect_equal(or3s(kln %in% c(4L, -3L, 2L, 7L, 8L), d > 0L, t < 0L),
bor3(kln %in% c(4L, -3L, 2L, 7L, 8L), d > 0L, t < 0L))
expect_equal(or3s(klo %in% c(4L, -3L, 2L, 7L, 8L), g > 1L, i < 1L),
bor3(klo %in% c(4L, -3L, 2L, 7L, 8L), g > 1L, i < 1L))
expect_equal(or3s(klp %in% c(4L, -3L, 2L, 7L, 8L), p > 9L, s < 9L),
bor3(klp %in% c(4L, -3L, 2L, 7L, 8L), p > 9L, s < 9L))
expect_equal(or3s(klq %in% 1:4, , ),
bor3(klq %in% 1:4, , ))
expect_equal(or3s(klr %in% 1:4, , ),
bor3(klr %in% 1:4, , ))
expect_equal(or3s(kls %in% 1:4, , ),
bor3(kls %in% 1:4, , ))
expect_equal(or3s(klt %in% 1:4, , k < 0L),
bor3(klt %in% 1:4, , k < 0L))
expect_equal(or3s(klu %in% 1:4, , c < 1L),
bor3(klu %in% 1:4, , c < 1L))
expect_equal(or3s(klv %in% 1:4, , d < 9L),
bor3(klv %in% 1:4, , d < 9L))
expect_equal(or3s(klw %in% 1:4, x > 0L, ),
bor3(klw %in% 1:4, x > 0L, ))
expect_equal(or3s(klx %in% 1:4, f > 1L, ),
bor3(klx %in% 1:4, f > 1L, ))
expect_equal(or3s(kly %in% 1:4, n > 9L, ),
bor3(kly %in% 1:4, n > 9L, ))
expect_equal(or3s(klz %in% 1:4, u > 0L, i < 0L),
bor3(klz %in% 1:4, u > 0L, i < 0L))
expect_equal(or3s(kma %in% 1:4, t > 1L, u < 1L),
bor3(kma %in% 1:4, t > 1L, u < 1L))
expect_equal(or3s(kmb %in% 1:4, p > 9L, w < 9L),
bor3(kmb %in% 1:4, p > 9L, w < 9L))
expect_equal(or3s(kmc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kmc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kmd %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kmd %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kme %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kme %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kmf %in% c(4L, -3L, 2L, 7L, 8L), , e <= 0L),
bor3(kmf %in% c(4L, -3L, 2L, 7L, 8L), , e <= 0L))
expect_equal(or3s(kmg %in% c(4L, -3L, 2L, 7L, 8L), , i <= 1L),
bor3(kmg %in% c(4L, -3L, 2L, 7L, 8L), , i <= 1L))
expect_equal(or3s(kmh %in% c(4L, -3L, 2L, 7L, 8L), , c <= 9L),
bor3(kmh %in% c(4L, -3L, 2L, 7L, 8L), , c <= 9L))
expect_equal(or3s(kmi %in% c(4L, -3L, 2L, 7L, 8L), o > 0L, ),
bor3(kmi %in% c(4L, -3L, 2L, 7L, 8L), o > 0L, ))
expect_equal(or3s(kmj %in% c(4L, -3L, 2L, 7L, 8L), u > 1L, ),
bor3(kmj %in% c(4L, -3L, 2L, 7L, 8L), u > 1L, ))
expect_equal(or3s(kmk %in% c(4L, -3L, 2L, 7L, 8L), z > 9L, ),
bor3(kmk %in% c(4L, -3L, 2L, 7L, 8L), z > 9L, ))
expect_equal(or3s(kml %in% c(4L, -3L, 2L, 7L, 8L), j > 0L, o <= 0L),
bor3(kml %in% c(4L, -3L, 2L, 7L, 8L), j > 0L, o <= 0L))
expect_equal(or3s(kmm %in% c(4L, -3L, 2L, 7L, 8L), p > 1L, b <= 1L),
bor3(kmm %in% c(4L, -3L, 2L, 7L, 8L), p > 1L, b <= 1L))
expect_equal(or3s(kmn %in% c(4L, -3L, 2L, 7L, 8L), n > 9L, v <= 9L),
bor3(kmn %in% c(4L, -3L, 2L, 7L, 8L), n > 9L, v <= 9L))
expect_equal(or3s(kmo %in% 1:4, , ),
bor3(kmo %in% 1:4, , ))
expect_equal(or3s(kmp %in% 1:4, , ),
bor3(kmp %in% 1:4, , ))
expect_equal(or3s(kmq %in% 1:4, , ),
bor3(kmq %in% 1:4, , ))
expect_equal(or3s(kmr %in% 1:4, , b <= 0L),
bor3(kmr %in% 1:4, , b <= 0L))
expect_equal(or3s(kms %in% 1:4, , l <= 1L),
bor3(kms %in% 1:4, , l <= 1L))
expect_equal(or3s(kmt %in% 1:4, , q <= 9L),
bor3(kmt %in% 1:4, , q <= 9L))
expect_equal(or3s(kmu %in% 1:4, s > 0L, ),
bor3(kmu %in% 1:4, s > 0L, ))
expect_equal(or3s(kmv %in% 1:4, k > 1L, ),
bor3(kmv %in% 1:4, k > 1L, ))
expect_equal(or3s(kmw %in% 1:4, r > 9L, ),
bor3(kmw %in% 1:4, r > 9L, ))
expect_equal(or3s(kmx %in% 1:4, v > 0L, y <= 0L),
bor3(kmx %in% 1:4, v > 0L, y <= 0L))
expect_equal(or3s(kmy %in% 1:4, v > 1L, v <= 1L),
bor3(kmy %in% 1:4, v > 1L, v <= 1L))
expect_equal(or3s(kmz %in% 1:4, k > 9L, l <= 9L),
bor3(kmz %in% 1:4, k > 9L, l <= 9L))
expect_equal(or3s(kna %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kna %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(knb %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(knb %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(knc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(knc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(knd %in% c(4L, -3L, 2L, 7L, 8L), , i == 0L),
bor3(knd %in% c(4L, -3L, 2L, 7L, 8L), , i == 0L))
expect_equal(or3s(kne %in% c(4L, -3L, 2L, 7L, 8L), , w == 1L),
bor3(kne %in% c(4L, -3L, 2L, 7L, 8L), , w == 1L))
expect_equal(or3s(knf %in% c(4L, -3L, 2L, 7L, 8L), , l == 9L),
bor3(knf %in% c(4L, -3L, 2L, 7L, 8L), , l == 9L))
expect_equal(or3s(kng %in% c(4L, -3L, 2L, 7L, 8L), g > 0L, ),
bor3(kng %in% c(4L, -3L, 2L, 7L, 8L), g > 0L, ))
expect_equal(or3s(knh %in% c(4L, -3L, 2L, 7L, 8L), h > 1L, ),
bor3(knh %in% c(4L, -3L, 2L, 7L, 8L), h > 1L, ))
expect_equal(or3s(kni %in% c(4L, -3L, 2L, 7L, 8L), b > 9L, ),
bor3(kni %in% c(4L, -3L, 2L, 7L, 8L), b > 9L, ))
expect_equal(or3s(knj %in% c(4L, -3L, 2L, 7L, 8L), c > 0L, t == 0L),
bor3(knj %in% c(4L, -3L, 2L, 7L, 8L), c > 0L, t == 0L))
expect_equal(or3s(knk %in% c(4L, -3L, 2L, 7L, 8L), h > 1L, v == 1L),
bor3(knk %in% c(4L, -3L, 2L, 7L, 8L), h > 1L, v == 1L))
expect_equal(or3s(knl %in% c(4L, -3L, 2L, 7L, 8L), t > 9L, b == 9L),
bor3(knl %in% c(4L, -3L, 2L, 7L, 8L), t > 9L, b == 9L))
expect_equal(or3s(knm %in% 1:4, , ),
bor3(knm %in% 1:4, , ))
expect_equal(or3s(knn %in% 1:4, , ),
bor3(knn %in% 1:4, , ))
expect_equal(or3s(kno %in% 1:4, , ),
bor3(kno %in% 1:4, , ))
expect_equal(or3s(knp %in% 1:4, , w == 0L),
bor3(knp %in% 1:4, , w == 0L))
expect_equal(or3s(knq %in% 1:4, , h == 1L),
bor3(knq %in% 1:4, , h == 1L))
expect_equal(or3s(knr %in% 1:4, , h == 9L),
bor3(knr %in% 1:4, , h == 9L))
expect_equal(or3s(kns %in% 1:4, u > 0L, ),
bor3(kns %in% 1:4, u > 0L, ))
expect_equal(or3s(knt %in% 1:4, y > 1L, ),
bor3(knt %in% 1:4, y > 1L, ))
expect_equal(or3s(knu %in% 1:4, c > 9L, ),
bor3(knu %in% 1:4, c > 9L, ))
expect_equal(or3s(knv %in% 1:4, f > 0L, k == 0L),
bor3(knv %in% 1:4, f > 0L, k == 0L))
expect_equal(or3s(knw %in% 1:4, f > 1L, m == 1L),
bor3(knw %in% 1:4, f > 1L, m == 1L))
expect_equal(or3s(knx %in% 1:4, m > 9L, e == 9L),
bor3(knx %in% 1:4, m > 9L, e == 9L))
expect_equal(or3s(kny %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kny %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(knz %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(knz %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(koa %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(koa %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kob %in% c(4L, -3L, 2L, 7L, 8L), , n > 0L),
bor3(kob %in% c(4L, -3L, 2L, 7L, 8L), , n > 0L))
expect_equal(or3s(koc %in% c(4L, -3L, 2L, 7L, 8L), , o > 1L),
bor3(koc %in% c(4L, -3L, 2L, 7L, 8L), , o > 1L))
expect_equal(or3s(kod %in% c(4L, -3L, 2L, 7L, 8L), , h > 9L),
bor3(kod %in% c(4L, -3L, 2L, 7L, 8L), , h > 9L))
expect_equal(or3s(koe %in% c(4L, -3L, 2L, 7L, 8L), r > 0L, ),
bor3(koe %in% c(4L, -3L, 2L, 7L, 8L), r > 0L, ))
expect_equal(or3s(kof %in% c(4L, -3L, 2L, 7L, 8L), d > 1L, ),
bor3(kof %in% c(4L, -3L, 2L, 7L, 8L), d > 1L, ))
expect_equal(or3s(kog %in% c(4L, -3L, 2L, 7L, 8L), a > 9L, ),
bor3(kog %in% c(4L, -3L, 2L, 7L, 8L), a > 9L, ))
expect_equal(or3s(koh %in% c(4L, -3L, 2L, 7L, 8L), i > 0L, u > 0L),
bor3(koh %in% c(4L, -3L, 2L, 7L, 8L), i > 0L, u > 0L))
expect_equal(or3s(koi %in% c(4L, -3L, 2L, 7L, 8L), y > 1L, a > 1L),
bor3(koi %in% c(4L, -3L, 2L, 7L, 8L), y > 1L, a > 1L))
expect_equal(or3s(koj %in% c(4L, -3L, 2L, 7L, 8L), g > 9L, r > 9L),
bor3(koj %in% c(4L, -3L, 2L, 7L, 8L), g > 9L, r > 9L))
expect_equal(or3s(kok %in% 1:4, , ),
bor3(kok %in% 1:4, , ))
expect_equal(or3s(kol %in% 1:4, , ),
bor3(kol %in% 1:4, , ))
expect_equal(or3s(kom %in% 1:4, , ),
bor3(kom %in% 1:4, , ))
expect_equal(or3s(kon %in% 1:4, , v > 0L),
bor3(kon %in% 1:4, , v > 0L))
expect_equal(or3s(koo %in% 1:4, , g > 1L),
bor3(koo %in% 1:4, , g > 1L))
expect_equal(or3s(kop %in% 1:4, , q > 9L),
bor3(kop %in% 1:4, , q > 9L))
expect_equal(or3s(koq %in% 1:4, j > 0L, ),
bor3(koq %in% 1:4, j > 0L, ))
expect_equal(or3s(kor %in% 1:4, m > 1L, ),
bor3(kor %in% 1:4, m > 1L, ))
expect_equal(or3s(kos %in% 1:4, e > 9L, ),
bor3(kos %in% 1:4, e > 9L, ))
expect_equal(or3s(kot %in% 1:4, l > 0L, r > 0L),
bor3(kot %in% 1:4, l > 0L, r > 0L))
expect_equal(or3s(kou %in% 1:4, h > 1L, c > 1L),
bor3(kou %in% 1:4, h > 1L, c > 1L))
expect_equal(or3s(kov %in% 1:4, e > 9L, a > 9L),
bor3(kov %in% 1:4, e > 9L, a > 9L))
expect_equal(or3s(kow %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kow %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kox %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kox %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(koy %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(koy %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(koz %in% c(4L, -3L, 2L, 7L, 8L), , y >= 0L),
bor3(koz %in% c(4L, -3L, 2L, 7L, 8L), , y >= 0L))
expect_equal(or3s(kpa %in% c(4L, -3L, 2L, 7L, 8L), , c >= 1L),
bor3(kpa %in% c(4L, -3L, 2L, 7L, 8L), , c >= 1L))
expect_equal(or3s(kpb %in% c(4L, -3L, 2L, 7L, 8L), , a >= 9L),
bor3(kpb %in% c(4L, -3L, 2L, 7L, 8L), , a >= 9L))
expect_equal(or3s(kpc %in% c(4L, -3L, 2L, 7L, 8L), g > 0L, ),
bor3(kpc %in% c(4L, -3L, 2L, 7L, 8L), g > 0L, ))
expect_equal(or3s(kpd %in% c(4L, -3L, 2L, 7L, 8L), l > 1L, ),
bor3(kpd %in% c(4L, -3L, 2L, 7L, 8L), l > 1L, ))
expect_equal(or3s(kpe %in% c(4L, -3L, 2L, 7L, 8L), t > 9L, ),
bor3(kpe %in% c(4L, -3L, 2L, 7L, 8L), t > 9L, ))
expect_equal(or3s(kpf %in% c(4L, -3L, 2L, 7L, 8L), z > 0L, y >= 0L),
bor3(kpf %in% c(4L, -3L, 2L, 7L, 8L), z > 0L, y >= 0L))
expect_equal(or3s(kpg %in% c(4L, -3L, 2L, 7L, 8L), r > 1L, b >= 1L),
bor3(kpg %in% c(4L, -3L, 2L, 7L, 8L), r > 1L, b >= 1L))
expect_equal(or3s(kph %in% c(4L, -3L, 2L, 7L, 8L), e > 9L, p >= 9L),
bor3(kph %in% c(4L, -3L, 2L, 7L, 8L), e > 9L, p >= 9L))
expect_equal(or3s(kpi %in% 1:4, , ),
bor3(kpi %in% 1:4, , ))
expect_equal(or3s(kpj %in% 1:4, , ),
bor3(kpj %in% 1:4, , ))
expect_equal(or3s(kpk %in% 1:4, , ),
bor3(kpk %in% 1:4, , ))
expect_equal(or3s(kpl %in% 1:4, , u >= 0L),
bor3(kpl %in% 1:4, , u >= 0L))
expect_equal(or3s(kpm %in% 1:4, , r >= 1L),
bor3(kpm %in% 1:4, , r >= 1L))
expect_equal(or3s(kpn %in% 1:4, , y >= 9L),
bor3(kpn %in% 1:4, , y >= 9L))
expect_equal(or3s(kpo %in% 1:4, v > 0L, ),
bor3(kpo %in% 1:4, v > 0L, ))
expect_equal(or3s(kpp %in% 1:4, z > 1L, ),
bor3(kpp %in% 1:4, z > 1L, ))
expect_equal(or3s(kpq %in% 1:4, h > 9L, ),
bor3(kpq %in% 1:4, h > 9L, ))
expect_equal(or3s(kpr %in% 1:4, a > 0L, b >= 0L),
bor3(kpr %in% 1:4, a > 0L, b >= 0L))
expect_equal(or3s(kps %in% 1:4, e > 1L, q >= 1L),
bor3(kps %in% 1:4, e > 1L, q >= 1L))
expect_equal(or3s(kpt %in% 1:4, w > 9L, r >= 9L),
bor3(kpt %in% 1:4, w > 9L, r >= 9L))
expect_equal(or3s(kpu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kpu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kpv %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kpv %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kpw %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kpw %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kpx %in% c(4L, -3L, 2L, 7L, 8L), , logi_v),
bor3(kpx %in% c(4L, -3L, 2L, 7L, 8L), , logi_v))
expect_equal(or3s(kpy %in% c(4L, -3L, 2L, 7L, 8L), , logi_h),
bor3(kpy %in% c(4L, -3L, 2L, 7L, 8L), , logi_h))
expect_equal(or3s(kpz %in% c(4L, -3L, 2L, 7L, 8L), , logi_k),
bor3(kpz %in% c(4L, -3L, 2L, 7L, 8L), , logi_k))
expect_equal(or3s(kqa %in% c(4L, -3L, 2L, 7L, 8L), b >= 0L, ),
bor3(kqa %in% c(4L, -3L, 2L, 7L, 8L), b >= 0L, ))
expect_equal(or3s(kqb %in% c(4L, -3L, 2L, 7L, 8L), x >= 1L, ),
bor3(kqb %in% c(4L, -3L, 2L, 7L, 8L), x >= 1L, ))
expect_equal(or3s(kqc %in% c(4L, -3L, 2L, 7L, 8L), i >= 9L, ),
bor3(kqc %in% c(4L, -3L, 2L, 7L, 8L), i >= 9L, ))
expect_equal(or3s(kqd %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, logi_c),
bor3(kqd %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, logi_c))
expect_equal(or3s(kqe %in% c(4L, -3L, 2L, 7L, 8L), y >= 1L, logi_i),
bor3(kqe %in% c(4L, -3L, 2L, 7L, 8L), y >= 1L, logi_i))
expect_equal(or3s(kqf %in% c(4L, -3L, 2L, 7L, 8L), w >= 9L, logi_y),
bor3(kqf %in% c(4L, -3L, 2L, 7L, 8L), w >= 9L, logi_y))
expect_equal(or3s(kqg %in% 1:4, , ),
bor3(kqg %in% 1:4, , ))
expect_equal(or3s(kqh %in% 1:4, , ),
bor3(kqh %in% 1:4, , ))
expect_equal(or3s(kqi %in% 1:4, , ),
bor3(kqi %in% 1:4, , ))
expect_equal(or3s(kqj %in% 1:4, , logi_b),
bor3(kqj %in% 1:4, , logi_b))
expect_equal(or3s(kqk %in% 1:4, , logi_o),
bor3(kqk %in% 1:4, , logi_o))
expect_equal(or3s(kql %in% 1:4, , logi_m),
bor3(kql %in% 1:4, , logi_m))
expect_equal(or3s(kqm %in% 1:4, e >= 0L, ),
bor3(kqm %in% 1:4, e >= 0L, ))
expect_equal(or3s(kqn %in% 1:4, s >= 1L, ),
bor3(kqn %in% 1:4, s >= 1L, ))
expect_equal(or3s(kqo %in% 1:4, d >= 9L, ),
bor3(kqo %in% 1:4, d >= 9L, ))
expect_equal(or3s(kqp %in% 1:4, u >= 0L, logi_n),
bor3(kqp %in% 1:4, u >= 0L, logi_n))
expect_equal(or3s(kqq %in% 1:4, s >= 1L, logi_k),
bor3(kqq %in% 1:4, s >= 1L, logi_k))
expect_equal(or3s(kqr %in% 1:4, h >= 9L, logi_n),
bor3(kqr %in% 1:4, h >= 9L, logi_n))
expect_equal(or3s(kqs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kqs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kqt %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kqt %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kqu %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kqu %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kqv %in% c(4L, -3L, 2L, 7L, 8L), , !logi_b),
bor3(kqv %in% c(4L, -3L, 2L, 7L, 8L), , !logi_b))
expect_equal(or3s(kqw %in% c(4L, -3L, 2L, 7L, 8L), , !logi_m),
bor3(kqw %in% c(4L, -3L, 2L, 7L, 8L), , !logi_m))
expect_equal(or3s(kqx %in% c(4L, -3L, 2L, 7L, 8L), , !logi_x),
bor3(kqx %in% c(4L, -3L, 2L, 7L, 8L), , !logi_x))
expect_equal(or3s(kqy %in% c(4L, -3L, 2L, 7L, 8L), r >= 0L, ),
bor3(kqy %in% c(4L, -3L, 2L, 7L, 8L), r >= 0L, ))
expect_equal(or3s(kqz %in% c(4L, -3L, 2L, 7L, 8L), f >= 1L, ),
bor3(kqz %in% c(4L, -3L, 2L, 7L, 8L), f >= 1L, ))
expect_equal(or3s(kra %in% c(4L, -3L, 2L, 7L, 8L), l >= 9L, ),
bor3(kra %in% c(4L, -3L, 2L, 7L, 8L), l >= 9L, ))
expect_equal(or3s(krb %in% c(4L, -3L, 2L, 7L, 8L), q >= 0L, !logi_f),
bor3(krb %in% c(4L, -3L, 2L, 7L, 8L), q >= 0L, !logi_f))
expect_equal(or3s(krc %in% c(4L, -3L, 2L, 7L, 8L), e >= 1L, !logi_l),
bor3(krc %in% c(4L, -3L, 2L, 7L, 8L), e >= 1L, !logi_l))
expect_equal(or3s(krd %in% c(4L, -3L, 2L, 7L, 8L), t >= 9L, !logi_t),
bor3(krd %in% c(4L, -3L, 2L, 7L, 8L), t >= 9L, !logi_t))
expect_equal(or3s(kre %in% 1:4, , ),
bor3(kre %in% 1:4, , ))
expect_equal(or3s(krf %in% 1:4, , ),
bor3(krf %in% 1:4, , ))
expect_equal(or3s(krg %in% 1:4, , ),
bor3(krg %in% 1:4, , ))
expect_equal(or3s(krh %in% 1:4, , !logi_d),
bor3(krh %in% 1:4, , !logi_d))
expect_equal(or3s(kri %in% 1:4, , !logi_r),
bor3(kri %in% 1:4, , !logi_r))
expect_equal(or3s(krj %in% 1:4, , !logi_n),
bor3(krj %in% 1:4, , !logi_n))
expect_equal(or3s(krk %in% 1:4, q >= 0L, ),
bor3(krk %in% 1:4, q >= 0L, ))
expect_equal(or3s(krl %in% 1:4, z >= 1L, ),
bor3(krl %in% 1:4, z >= 1L, ))
expect_equal(or3s(krm %in% 1:4, j >= 9L, ),
bor3(krm %in% 1:4, j >= 9L, ))
expect_equal(or3s(krn %in% 1:4, b >= 0L, !logi_q),
bor3(krn %in% 1:4, b >= 0L, !logi_q))
expect_equal(or3s(kro %in% 1:4, q >= 1L, !logi_y),
bor3(kro %in% 1:4, q >= 1L, !logi_y))
expect_equal(or3s(krp %in% 1:4, f >= 9L, !logi_z),
bor3(krp %in% 1:4, f >= 9L, !logi_z))
expect_equal(or3s(krq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(krq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(krr %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(krr %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(krs %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(krs %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(krt %in% c(4L, -3L, 2L, 7L, 8L), , o != 0L),
bor3(krt %in% c(4L, -3L, 2L, 7L, 8L), , o != 0L))
expect_equal(or3s(kru %in% c(4L, -3L, 2L, 7L, 8L), , e != 1L),
bor3(kru %in% c(4L, -3L, 2L, 7L, 8L), , e != 1L))
expect_equal(or3s(krv %in% c(4L, -3L, 2L, 7L, 8L), , z != 9L),
bor3(krv %in% c(4L, -3L, 2L, 7L, 8L), , z != 9L))
expect_equal(or3s(krw %in% c(4L, -3L, 2L, 7L, 8L), k >= 0L, ),
bor3(krw %in% c(4L, -3L, 2L, 7L, 8L), k >= 0L, ))
expect_equal(or3s(krx %in% c(4L, -3L, 2L, 7L, 8L), r >= 1L, ),
bor3(krx %in% c(4L, -3L, 2L, 7L, 8L), r >= 1L, ))
expect_equal(or3s(kry %in% c(4L, -3L, 2L, 7L, 8L), l >= 9L, ),
bor3(kry %in% c(4L, -3L, 2L, 7L, 8L), l >= 9L, ))
expect_equal(or3s(krz %in% c(4L, -3L, 2L, 7L, 8L), q >= 0L, c != 0L),
bor3(krz %in% c(4L, -3L, 2L, 7L, 8L), q >= 0L, c != 0L))
expect_equal(or3s(ksa %in% c(4L, -3L, 2L, 7L, 8L), m >= 1L, y != 1L),
bor3(ksa %in% c(4L, -3L, 2L, 7L, 8L), m >= 1L, y != 1L))
expect_equal(or3s(ksb %in% c(4L, -3L, 2L, 7L, 8L), p >= 9L, f != 9L),
bor3(ksb %in% c(4L, -3L, 2L, 7L, 8L), p >= 9L, f != 9L))
expect_equal(or3s(ksc %in% 1:4, , ),
bor3(ksc %in% 1:4, , ))
expect_equal(or3s(ksd %in% 1:4, , ),
bor3(ksd %in% 1:4, , ))
expect_equal(or3s(kse %in% 1:4, , ),
bor3(kse %in% 1:4, , ))
expect_equal(or3s(ksf %in% 1:4, , g != 0L),
bor3(ksf %in% 1:4, , g != 0L))
expect_equal(or3s(ksg %in% 1:4, , q != 1L),
bor3(ksg %in% 1:4, , q != 1L))
expect_equal(or3s(ksh %in% 1:4, , s != 9L),
bor3(ksh %in% 1:4, , s != 9L))
expect_equal(or3s(ksi %in% 1:4, y >= 0L, ),
bor3(ksi %in% 1:4, y >= 0L, ))
expect_equal(or3s(ksj %in% 1:4, f >= 1L, ),
bor3(ksj %in% 1:4, f >= 1L, ))
expect_equal(or3s(ksk %in% 1:4, b >= 9L, ),
bor3(ksk %in% 1:4, b >= 9L, ))
expect_equal(or3s(ksl %in% 1:4, v >= 0L, r != 0L),
bor3(ksl %in% 1:4, v >= 0L, r != 0L))
expect_equal(or3s(ksm %in% 1:4, d >= 1L, n != 1L),
bor3(ksm %in% 1:4, d >= 1L, n != 1L))
expect_equal(or3s(ksn %in% 1:4, b >= 9L, u != 9L),
bor3(ksn %in% 1:4, b >= 9L, u != 9L))
expect_equal(or3s(kso %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kso %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ksp %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ksp %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ksq %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ksq %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ksr %in% c(4L, -3L, 2L, 7L, 8L), , b %between% c(-1L, 1L)),
bor3(ksr %in% c(4L, -3L, 2L, 7L, 8L), , b %between% c(-1L, 1L)))
expect_equal(or3s(kss %in% c(4L, -3L, 2L, 7L, 8L), , p %between% c(-1L, 1L)),
bor3(kss %in% c(4L, -3L, 2L, 7L, 8L), , p %between% c(-1L, 1L)))
expect_equal(or3s(kst %in% c(4L, -3L, 2L, 7L, 8L), , y %between% c(-1L, 1L)),
bor3(kst %in% c(4L, -3L, 2L, 7L, 8L), , y %between% c(-1L, 1L)))
expect_equal(or3s(ksu %in% c(4L, -3L, 2L, 7L, 8L), v >= 0L, ),
bor3(ksu %in% c(4L, -3L, 2L, 7L, 8L), v >= 0L, ))
expect_equal(or3s(ksv %in% c(4L, -3L, 2L, 7L, 8L), o >= 1L, ),
bor3(ksv %in% c(4L, -3L, 2L, 7L, 8L), o >= 1L, ))
expect_equal(or3s(ksw %in% c(4L, -3L, 2L, 7L, 8L), m >= 9L, ),
bor3(ksw %in% c(4L, -3L, 2L, 7L, 8L), m >= 9L, ))
expect_equal(or3s(ksx %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, e %between% c(-1L, 1L)),
bor3(ksx %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, e %between% c(-1L, 1L)))
expect_equal(or3s(ksy %in% c(4L, -3L, 2L, 7L, 8L), e >= 1L, t %between% c(-1L, 1L)),
bor3(ksy %in% c(4L, -3L, 2L, 7L, 8L), e >= 1L, t %between% c(-1L, 1L)))
expect_equal(or3s(ksz %in% c(4L, -3L, 2L, 7L, 8L), w >= 9L, a %between% c(-1L, 1L)),
bor3(ksz %in% c(4L, -3L, 2L, 7L, 8L), w >= 9L, a %between% c(-1L, 1L)))
expect_equal(or3s(kta %in% 1:4, , ),
bor3(kta %in% 1:4, , ))
expect_equal(or3s(ktb %in% 1:4, , ),
bor3(ktb %in% 1:4, , ))
expect_equal(or3s(ktc %in% 1:4, , ),
bor3(ktc %in% 1:4, , ))
expect_equal(or3s(ktd %in% 1:4, , a %between% c(-1L, 1L)),
bor3(ktd %in% 1:4, , a %between% c(-1L, 1L)))
expect_equal(or3s(kte %in% 1:4, , u %between% c(-1L, 1L)),
bor3(kte %in% 1:4, , u %between% c(-1L, 1L)))
expect_equal(or3s(ktf %in% 1:4, , n %between% c(-1L, 1L)),
bor3(ktf %in% 1:4, , n %between% c(-1L, 1L)))
expect_equal(or3s(ktg %in% 1:4, f >= 0L, ),
bor3(ktg %in% 1:4, f >= 0L, ))
expect_equal(or3s(kth %in% 1:4, l >= 1L, ),
bor3(kth %in% 1:4, l >= 1L, ))
expect_equal(or3s(kti %in% 1:4, l >= 9L, ),
bor3(kti %in% 1:4, l >= 9L, ))
expect_equal(or3s(ktj %in% 1:4, l >= 0L, f %between% c(-1L, 1L)),
bor3(ktj %in% 1:4, l >= 0L, f %between% c(-1L, 1L)))
expect_equal(or3s(ktk %in% 1:4, g >= 1L, a %between% c(-1L, 1L)),
bor3(ktk %in% 1:4, g >= 1L, a %between% c(-1L, 1L)))
expect_equal(or3s(ktl %in% 1:4, m >= 9L, r %between% c(-1L, 1L)),
bor3(ktl %in% 1:4, m >= 9L, r %between% c(-1L, 1L)))
expect_equal(or3s(ktm %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ktm %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ktn %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(ktn %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kto %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kto %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(ktp %in% c(4L, -3L, 2L, 7L, 8L), , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ktp %in% c(4L, -3L, 2L, 7L, 8L), , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ktq %in% c(4L, -3L, 2L, 7L, 8L), , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ktq %in% c(4L, -3L, 2L, 7L, 8L), , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ktr %in% c(4L, -3L, 2L, 7L, 8L), , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ktr %in% c(4L, -3L, 2L, 7L, 8L), , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kts %in% c(4L, -3L, 2L, 7L, 8L), c >= 0L, ),
bor3(kts %in% c(4L, -3L, 2L, 7L, 8L), c >= 0L, ))
expect_equal(or3s(ktt %in% c(4L, -3L, 2L, 7L, 8L), n >= 1L, ),
bor3(ktt %in% c(4L, -3L, 2L, 7L, 8L), n >= 1L, ))
expect_equal(or3s(ktu %in% c(4L, -3L, 2L, 7L, 8L), p >= 9L, ),
bor3(ktu %in% c(4L, -3L, 2L, 7L, 8L), p >= 9L, ))
expect_equal(or3s(ktv %in% c(4L, -3L, 2L, 7L, 8L), g >= 0L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ktv %in% c(4L, -3L, 2L, 7L, 8L), g >= 0L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ktw %in% c(4L, -3L, 2L, 7L, 8L), k >= 1L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ktw %in% c(4L, -3L, 2L, 7L, 8L), k >= 1L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ktx %in% c(4L, -3L, 2L, 7L, 8L), j >= 9L, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ktx %in% c(4L, -3L, 2L, 7L, 8L), j >= 9L, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(kty %in% 1:4, , ),
bor3(kty %in% 1:4, , ))
expect_equal(or3s(ktz %in% 1:4, , ),
bor3(ktz %in% 1:4, , ))
expect_equal(or3s(kua %in% 1:4, , ),
bor3(kua %in% 1:4, , ))
expect_equal(or3s(kub %in% 1:4, , t %in% 1:4),
bor3(kub %in% 1:4, , t %in% 1:4))
expect_equal(or3s(kuc %in% 1:4, , q %in% 1:4),
bor3(kuc %in% 1:4, , q %in% 1:4))
expect_equal(or3s(kud %in% 1:4, , g %in% 1:4),
bor3(kud %in% 1:4, , g %in% 1:4))
expect_equal(or3s(kue %in% 1:4, b >= 0L, ),
bor3(kue %in% 1:4, b >= 0L, ))
expect_equal(or3s(kuf %in% 1:4, v >= 1L, ),
bor3(kuf %in% 1:4, v >= 1L, ))
expect_equal(or3s(kug %in% 1:4, n >= 9L, ),
bor3(kug %in% 1:4, n >= 9L, ))
expect_equal(or3s(kuh %in% 1:4, g >= 0L, g %in% 1:4),
bor3(kuh %in% 1:4, g >= 0L, g %in% 1:4))
expect_equal(or3s(kui %in% 1:4, h >= 1L, y %in% 1:4),
bor3(kui %in% 1:4, h >= 1L, y %in% 1:4))
expect_equal(or3s(kuj %in% 1:4, n >= 9L, x %in% 1:4),
bor3(kuj %in% 1:4, n >= 9L, x %in% 1:4))
expect_equal(or3s(kuk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kuk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kul %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kul %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kum %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kum %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kun %in% c(4L, -3L, 2L, 7L, 8L), , q < 0L),
bor3(kun %in% c(4L, -3L, 2L, 7L, 8L), , q < 0L))
expect_equal(or3s(kuo %in% c(4L, -3L, 2L, 7L, 8L), , r < 1L),
bor3(kuo %in% c(4L, -3L, 2L, 7L, 8L), , r < 1L))
expect_equal(or3s(kup %in% c(4L, -3L, 2L, 7L, 8L), , f < 9L),
bor3(kup %in% c(4L, -3L, 2L, 7L, 8L), , f < 9L))
expect_equal(or3s(kuq %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, ),
bor3(kuq %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, ))
expect_equal(or3s(kur %in% c(4L, -3L, 2L, 7L, 8L), y >= 1L, ),
bor3(kur %in% c(4L, -3L, 2L, 7L, 8L), y >= 1L, ))
expect_equal(or3s(kus %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L, ),
bor3(kus %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L, ))
expect_equal(or3s(kut %in% c(4L, -3L, 2L, 7L, 8L), t >= 0L, c < 0L),
bor3(kut %in% c(4L, -3L, 2L, 7L, 8L), t >= 0L, c < 0L))
expect_equal(or3s(kuu %in% c(4L, -3L, 2L, 7L, 8L), l >= 1L, r < 1L),
bor3(kuu %in% c(4L, -3L, 2L, 7L, 8L), l >= 1L, r < 1L))
expect_equal(or3s(kuv %in% c(4L, -3L, 2L, 7L, 8L), q >= 9L, e < 9L),
bor3(kuv %in% c(4L, -3L, 2L, 7L, 8L), q >= 9L, e < 9L))
expect_equal(or3s(kuw %in% 1:4, , ),
bor3(kuw %in% 1:4, , ))
expect_equal(or3s(kux %in% 1:4, , ),
bor3(kux %in% 1:4, , ))
expect_equal(or3s(kuy %in% 1:4, , ),
bor3(kuy %in% 1:4, , ))
expect_equal(or3s(kuz %in% 1:4, , x < 0L),
bor3(kuz %in% 1:4, , x < 0L))
expect_equal(or3s(kva %in% 1:4, , i < 1L),
bor3(kva %in% 1:4, , i < 1L))
expect_equal(or3s(kvb %in% 1:4, , z < 9L),
bor3(kvb %in% 1:4, , z < 9L))
expect_equal(or3s(kvc %in% 1:4, x >= 0L, ),
bor3(kvc %in% 1:4, x >= 0L, ))
expect_equal(or3s(kvd %in% 1:4, p >= 1L, ),
bor3(kvd %in% 1:4, p >= 1L, ))
expect_equal(or3s(kve %in% 1:4, h >= 9L, ),
bor3(kve %in% 1:4, h >= 9L, ))
expect_equal(or3s(kvf %in% 1:4, a >= 0L, b < 0L),
bor3(kvf %in% 1:4, a >= 0L, b < 0L))
expect_equal(or3s(kvg %in% 1:4, r >= 1L, c < 1L),
bor3(kvg %in% 1:4, r >= 1L, c < 1L))
expect_equal(or3s(kvh %in% 1:4, b >= 9L, d < 9L),
bor3(kvh %in% 1:4, b >= 9L, d < 9L))
expect_equal(or3s(kvi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kvi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kvj %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kvj %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kvk %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kvk %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kvl %in% c(4L, -3L, 2L, 7L, 8L), , l <= 0L),
bor3(kvl %in% c(4L, -3L, 2L, 7L, 8L), , l <= 0L))
expect_equal(or3s(kvm %in% c(4L, -3L, 2L, 7L, 8L), , r <= 1L),
bor3(kvm %in% c(4L, -3L, 2L, 7L, 8L), , r <= 1L))
expect_equal(or3s(kvn %in% c(4L, -3L, 2L, 7L, 8L), , x <= 9L),
bor3(kvn %in% c(4L, -3L, 2L, 7L, 8L), , x <= 9L))
expect_equal(or3s(kvo %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, ),
bor3(kvo %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L, ))
expect_equal(or3s(kvp %in% c(4L, -3L, 2L, 7L, 8L), b >= 1L, ),
bor3(kvp %in% c(4L, -3L, 2L, 7L, 8L), b >= 1L, ))
expect_equal(or3s(kvq %in% c(4L, -3L, 2L, 7L, 8L), o >= 9L, ),
bor3(kvq %in% c(4L, -3L, 2L, 7L, 8L), o >= 9L, ))
expect_equal(or3s(kvr %in% c(4L, -3L, 2L, 7L, 8L), z >= 0L, d <= 0L),
bor3(kvr %in% c(4L, -3L, 2L, 7L, 8L), z >= 0L, d <= 0L))
expect_equal(or3s(kvs %in% c(4L, -3L, 2L, 7L, 8L), c >= 1L, j <= 1L),
bor3(kvs %in% c(4L, -3L, 2L, 7L, 8L), c >= 1L, j <= 1L))
expect_equal(or3s(kvt %in% c(4L, -3L, 2L, 7L, 8L), a >= 9L, u <= 9L),
bor3(kvt %in% c(4L, -3L, 2L, 7L, 8L), a >= 9L, u <= 9L))
expect_equal(or3s(kvu %in% 1:4, , ),
bor3(kvu %in% 1:4, , ))
expect_equal(or3s(kvv %in% 1:4, , ),
bor3(kvv %in% 1:4, , ))
expect_equal(or3s(kvw %in% 1:4, , ),
bor3(kvw %in% 1:4, , ))
expect_equal(or3s(kvx %in% 1:4, , m <= 0L),
bor3(kvx %in% 1:4, , m <= 0L))
expect_equal(or3s(kvy %in% 1:4, , c <= 1L),
bor3(kvy %in% 1:4, , c <= 1L))
expect_equal(or3s(kvz %in% 1:4, , q <= 9L),
bor3(kvz %in% 1:4, , q <= 9L))
expect_equal(or3s(kwa %in% 1:4, x >= 0L, ),
bor3(kwa %in% 1:4, x >= 0L, ))
expect_equal(or3s(kwb %in% 1:4, o >= 1L, ),
bor3(kwb %in% 1:4, o >= 1L, ))
expect_equal(or3s(kwc %in% 1:4, w >= 9L, ),
bor3(kwc %in% 1:4, w >= 9L, ))
expect_equal(or3s(kwd %in% 1:4, v >= 0L, o <= 0L),
bor3(kwd %in% 1:4, v >= 0L, o <= 0L))
expect_equal(or3s(kwe %in% 1:4, k >= 1L, w <= 1L),
bor3(kwe %in% 1:4, k >= 1L, w <= 1L))
expect_equal(or3s(kwf %in% 1:4, l >= 9L, y <= 9L),
bor3(kwf %in% 1:4, l >= 9L, y <= 9L))
expect_equal(or3s(kwg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kwg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kwh %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kwh %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kwi %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kwi %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kwj %in% c(4L, -3L, 2L, 7L, 8L), , e == 0L),
bor3(kwj %in% c(4L, -3L, 2L, 7L, 8L), , e == 0L))
expect_equal(or3s(kwk %in% c(4L, -3L, 2L, 7L, 8L), , r == 1L),
bor3(kwk %in% c(4L, -3L, 2L, 7L, 8L), , r == 1L))
expect_equal(or3s(kwl %in% c(4L, -3L, 2L, 7L, 8L), , i == 9L),
bor3(kwl %in% c(4L, -3L, 2L, 7L, 8L), , i == 9L))
expect_equal(or3s(kwm %in% c(4L, -3L, 2L, 7L, 8L), t >= 0L, ),
bor3(kwm %in% c(4L, -3L, 2L, 7L, 8L), t >= 0L, ))
expect_equal(or3s(kwn %in% c(4L, -3L, 2L, 7L, 8L), s >= 1L, ),
bor3(kwn %in% c(4L, -3L, 2L, 7L, 8L), s >= 1L, ))
expect_equal(or3s(kwo %in% c(4L, -3L, 2L, 7L, 8L), o >= 9L, ),
bor3(kwo %in% c(4L, -3L, 2L, 7L, 8L), o >= 9L, ))
expect_equal(or3s(kwp %in% c(4L, -3L, 2L, 7L, 8L), z >= 0L, x == 0L),
bor3(kwp %in% c(4L, -3L, 2L, 7L, 8L), z >= 0L, x == 0L))
expect_equal(or3s(kwq %in% c(4L, -3L, 2L, 7L, 8L), r >= 1L, t == 1L),
bor3(kwq %in% c(4L, -3L, 2L, 7L, 8L), r >= 1L, t == 1L))
expect_equal(or3s(kwr %in% c(4L, -3L, 2L, 7L, 8L), j >= 9L, r == 9L),
bor3(kwr %in% c(4L, -3L, 2L, 7L, 8L), j >= 9L, r == 9L))
expect_equal(or3s(kws %in% 1:4, , ),
bor3(kws %in% 1:4, , ))
expect_equal(or3s(kwt %in% 1:4, , ),
bor3(kwt %in% 1:4, , ))
expect_equal(or3s(kwu %in% 1:4, , ),
bor3(kwu %in% 1:4, , ))
expect_equal(or3s(kwv %in% 1:4, , o == 0L),
bor3(kwv %in% 1:4, , o == 0L))
expect_equal(or3s(kww %in% 1:4, , j == 1L),
bor3(kww %in% 1:4, , j == 1L))
expect_equal(or3s(kwx %in% 1:4, , k == 9L),
bor3(kwx %in% 1:4, , k == 9L))
expect_equal(or3s(kwy %in% 1:4, h >= 0L, ),
bor3(kwy %in% 1:4, h >= 0L, ))
expect_equal(or3s(kwz %in% 1:4, f >= 1L, ),
bor3(kwz %in% 1:4, f >= 1L, ))
expect_equal(or3s(kxa %in% 1:4, c >= 9L, ),
bor3(kxa %in% 1:4, c >= 9L, ))
expect_equal(or3s(kxb %in% 1:4, c >= 0L, v == 0L),
bor3(kxb %in% 1:4, c >= 0L, v == 0L))
expect_equal(or3s(kxc %in% 1:4, z >= 1L, e == 1L),
bor3(kxc %in% 1:4, z >= 1L, e == 1L))
expect_equal(or3s(kxd %in% 1:4, v >= 9L, e == 9L),
bor3(kxd %in% 1:4, v >= 9L, e == 9L))
expect_equal(or3s(kxe %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kxe %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kxf %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kxf %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kxg %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kxg %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kxh %in% c(4L, -3L, 2L, 7L, 8L), , h > 0L),
bor3(kxh %in% c(4L, -3L, 2L, 7L, 8L), , h > 0L))
expect_equal(or3s(kxi %in% c(4L, -3L, 2L, 7L, 8L), , l > 1L),
bor3(kxi %in% c(4L, -3L, 2L, 7L, 8L), , l > 1L))
expect_equal(or3s(kxj %in% c(4L, -3L, 2L, 7L, 8L), , f > 9L),
bor3(kxj %in% c(4L, -3L, 2L, 7L, 8L), , f > 9L))
expect_equal(or3s(kxk %in% c(4L, -3L, 2L, 7L, 8L), j >= 0L, ),
bor3(kxk %in% c(4L, -3L, 2L, 7L, 8L), j >= 0L, ))
expect_equal(or3s(kxl %in% c(4L, -3L, 2L, 7L, 8L), n >= 1L, ),
bor3(kxl %in% c(4L, -3L, 2L, 7L, 8L), n >= 1L, ))
expect_equal(or3s(kxm %in% c(4L, -3L, 2L, 7L, 8L), h >= 9L, ),
bor3(kxm %in% c(4L, -3L, 2L, 7L, 8L), h >= 9L, ))
expect_equal(or3s(kxn %in% c(4L, -3L, 2L, 7L, 8L), x >= 0L, e > 0L),
bor3(kxn %in% c(4L, -3L, 2L, 7L, 8L), x >= 0L, e > 0L))
expect_equal(or3s(kxo %in% c(4L, -3L, 2L, 7L, 8L), n >= 1L, v > 1L),
bor3(kxo %in% c(4L, -3L, 2L, 7L, 8L), n >= 1L, v > 1L))
expect_equal(or3s(kxp %in% c(4L, -3L, 2L, 7L, 8L), a >= 9L, f > 9L),
bor3(kxp %in% c(4L, -3L, 2L, 7L, 8L), a >= 9L, f > 9L))
expect_equal(or3s(kxq %in% 1:4, , ),
bor3(kxq %in% 1:4, , ))
expect_equal(or3s(kxr %in% 1:4, , ),
bor3(kxr %in% 1:4, , ))
expect_equal(or3s(kxs %in% 1:4, , ),
bor3(kxs %in% 1:4, , ))
expect_equal(or3s(kxt %in% 1:4, , p > 0L),
bor3(kxt %in% 1:4, , p > 0L))
expect_equal(or3s(kxu %in% 1:4, , w > 1L),
bor3(kxu %in% 1:4, , w > 1L))
expect_equal(or3s(kxv %in% 1:4, , a > 9L),
bor3(kxv %in% 1:4, , a > 9L))
expect_equal(or3s(kxw %in% 1:4, j >= 0L, ),
bor3(kxw %in% 1:4, j >= 0L, ))
expect_equal(or3s(kxx %in% 1:4, d >= 1L, ),
bor3(kxx %in% 1:4, d >= 1L, ))
expect_equal(or3s(kxy %in% 1:4, t >= 9L, ),
bor3(kxy %in% 1:4, t >= 9L, ))
expect_equal(or3s(kxz %in% 1:4, l >= 0L, z > 0L),
bor3(kxz %in% 1:4, l >= 0L, z > 0L))
expect_equal(or3s(kya %in% 1:4, r >= 1L, m > 1L),
bor3(kya %in% 1:4, r >= 1L, m > 1L))
expect_equal(or3s(kyb %in% 1:4, z >= 9L, a > 9L),
bor3(kyb %in% 1:4, z >= 9L, a > 9L))
expect_equal(or3s(kyc %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kyc %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kyd %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kyd %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kye %in% c(4L, -3L, 2L, 7L, 8L), , ),
bor3(kye %in% c(4L, -3L, 2L, 7L, 8L), , ))
expect_equal(or3s(kyf %in% c(4L, -3L, 2L, 7L, 8L), , i >= 0L),
bor3(kyf %in% c(4L, -3L, 2L, 7L, 8L), , i >= 0L))
expect_equal(or3s(kyg %in% c(4L, -3L, 2L, 7L, 8L), , y >= 1L),
bor3(kyg %in% c(4L, -3L, 2L, 7L, 8L), , y >= 1L))
expect_equal(or3s(kyh %in% c(4L, -3L, 2L, 7L, 8L), , k >= 9L),
bor3(kyh %in% c(4L, -3L, 2L, 7L, 8L), , k >= 9L))
expect_equal(or3s(kyi %in% c(4L, -3L, 2L, 7L, 8L), y >= 0L, ),
bor3(kyi %in% c(4L, -3L, 2L, 7L, 8L), y >= 0L, ))
expect_equal(or3s(kyj %in% c(4L, -3L, 2L, 7L, 8L), l >= 1L, ),
bor3(kyj %in% c(4L, -3L, 2L, 7L, 8L), l >= 1L, ))
expect_equal(or3s(kyk %in% c(4L, -3L, 2L, 7L, 8L), y >= 9L, ),
bor3(kyk %in% c(4L, -3L, 2L, 7L, 8L), y >= 9L, ))
expect_equal(or3s(kyl %in% c(4L, -3L, 2L, 7L, 8L), l >= 0L, p >= 0L),
bor3(kyl %in% c(4L, -3L, 2L, 7L, 8L), l >= 0L, p >= 0L))
expect_equal(or3s(kym %in% c(4L, -3L, 2L, 7L, 8L), d >= 1L, c >= 1L),
bor3(kym %in% c(4L, -3L, 2L, 7L, 8L), d >= 1L, c >= 1L))
expect_equal(or3s(kyn %in% c(4L, -3L, 2L, 7L, 8L), r >= 9L, p >= 9L),
bor3(kyn %in% c(4L, -3L, 2L, 7L, 8L), r >= 9L, p >= 9L))
expect_equal(or3s(kyo %in% 1:4, , ),
bor3(kyo %in% 1:4, , ))
expect_equal(or3s(kyp %in% 1:4, , ),
bor3(kyp %in% 1:4, , ))
expect_equal(or3s(kyq %in% 1:4, , ),
bor3(kyq %in% 1:4, , ))
expect_equal(or3s(kyr %in% 1:4, , x >= 0L),
bor3(kyr %in% 1:4, , x >= 0L))
expect_equal(or3s(kys %in% 1:4, , k >= 1L),
bor3(kys %in% 1:4, , k >= 1L))
expect_equal(or3s(kyt %in% 1:4, , k >= 9L),
bor3(kyt %in% 1:4, , k >= 9L))
expect_equal(or3s(kyu %in% 1:4, c >= 0L, ),
bor3(kyu %in% 1:4, c >= 0L, ))
expect_equal(or3s(kyv %in% 1:4, h >= 1L, ),
bor3(kyv %in% 1:4, h >= 1L, ))
expect_equal(or3s(kyw %in% 1:4, g >= 9L, ),
bor3(kyw %in% 1:4, g >= 9L, ))
expect_equal(or3s(kyx %in% 1:4, b >= 0L, t >= 0L),
bor3(kyx %in% 1:4, b >= 0L, t >= 0L))
expect_equal(or3s(kyy %in% 1:4, t >= 1L, t >= 1L),
bor3(kyy %in% 1:4, t >= 1L, t >= 1L))
expect_equal(or3s(kyz %in% 1:4, s >= 9L, f >= 9L),
bor3(kyz %in% 1:4, s >= 9L, f >= 9L))
expect_equal(or3s(la < 0L, , ),
bor3(la < 0L, , ))
expect_equal(or3s(lb < 1L, , ),
bor3(lb < 1L, , ))
expect_equal(or3s(lc < 9L, , ),
bor3(lc < 9L, , ))
expect_equal(or3s(ld < 0L, , logi_z),
bor3(ld < 0L, , logi_z))
expect_equal(or3s(le < 1L, , logi_v),
bor3(le < 1L, , logi_v))
expect_equal(or3s(lf < 9L, , logi_o),
bor3(lf < 9L, , logi_o))
expect_equal(or3s(lg < 0L, logi_j, ),
bor3(lg < 0L, logi_j, ))
expect_equal(or3s(lh < 1L, logi_z, ),
bor3(lh < 1L, logi_z, ))
expect_equal(or3s(li < 9L, logi_x, ),
bor3(li < 9L, logi_x, ))
expect_equal(or3s(lj < 0L, logi_v, logi_j),
bor3(lj < 0L, logi_v, logi_j))
expect_equal(or3s(lk < 1L, logi_k, logi_l),
bor3(lk < 1L, logi_k, logi_l))
expect_equal(or3s(ll < 9L, logi_m, logi_c),
bor3(ll < 9L, logi_m, logi_c))
expect_equal(or3s(lm < 0L, , ),
bor3(lm < 0L, , ))
expect_equal(or3s(ln < 1L, , ),
bor3(ln < 1L, , ))
expect_equal(or3s(lo < 9L, , ),
bor3(lo < 9L, , ))
expect_equal(or3s(lp < 0L, , !logi_j),
bor3(lp < 0L, , !logi_j))
expect_equal(or3s(lq < 1L, , !logi_z),
bor3(lq < 1L, , !logi_z))
expect_equal(or3s(lr < 9L, , !logi_j),
bor3(lr < 9L, , !logi_j))
expect_equal(or3s(ls < 0L, logi_h, ),
bor3(ls < 0L, logi_h, ))
expect_equal(or3s(lt < 1L, logi_u, ),
bor3(lt < 1L, logi_u, ))
expect_equal(or3s(lu < 9L, logi_w, ),
bor3(lu < 9L, logi_w, ))
expect_equal(or3s(lv < 0L, logi_v, !logi_p),
bor3(lv < 0L, logi_v, !logi_p))
expect_equal(or3s(lw < 1L, logi_q, !logi_g),
bor3(lw < 1L, logi_q, !logi_g))
expect_equal(or3s(lx < 9L, logi_t, !logi_u),
bor3(lx < 9L, logi_t, !logi_u))
expect_equal(or3s(ly < 0L, , ),
bor3(ly < 0L, , ))
expect_equal(or3s(lz < 1L, , ),
bor3(lz < 1L, , ))
expect_equal(or3s(laa < 9L, , ),
bor3(laa < 9L, , ))
expect_equal(or3s(lab < 0L, , h != 0L),
bor3(lab < 0L, , h != 0L))
expect_equal(or3s(lac < 1L, , n != 1L),
bor3(lac < 1L, , n != 1L))
expect_equal(or3s(lad < 9L, , r != 9L),
bor3(lad < 9L, , r != 9L))
expect_equal(or3s(lae < 0L, logi_g, ),
bor3(lae < 0L, logi_g, ))
expect_equal(or3s(laf < 1L, logi_v, ),
bor3(laf < 1L, logi_v, ))
expect_equal(or3s(lag < 9L, logi_z, ),
bor3(lag < 9L, logi_z, ))
expect_equal(or3s(lah < 0L, logi_e, h != 0L),
bor3(lah < 0L, logi_e, h != 0L))
expect_equal(or3s(lai < 1L, logi_z, l != 1L),
bor3(lai < 1L, logi_z, l != 1L))
expect_equal(or3s(laj < 9L, logi_t, y != 9L),
bor3(laj < 9L, logi_t, y != 9L))
expect_equal(or3s(lak < 0L, , ),
bor3(lak < 0L, , ))
expect_equal(or3s(lal < 1L, , ),
bor3(lal < 1L, , ))
expect_equal(or3s(lam < 9L, , ),
bor3(lam < 9L, , ))
expect_equal(or3s(lan < 0L, , o %between% c(-1L, 1L)),
bor3(lan < 0L, , o %between% c(-1L, 1L)))
expect_equal(or3s(lao < 1L, , y %between% c(-1L, 1L)),
bor3(lao < 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(lap < 9L, , c %between% c(-1L, 1L)),
bor3(lap < 9L, , c %between% c(-1L, 1L)))
expect_equal(or3s(laq < 0L, logi_u, ),
bor3(laq < 0L, logi_u, ))
expect_equal(or3s(lar < 1L, logi_u, ),
bor3(lar < 1L, logi_u, ))
expect_equal(or3s(las < 9L, logi_r, ),
bor3(las < 9L, logi_r, ))
expect_equal(or3s(lat < 0L, logi_x, v %between% c(-1L, 1L)),
bor3(lat < 0L, logi_x, v %between% c(-1L, 1L)))
expect_equal(or3s(lau < 1L, logi_k, v %between% c(-1L, 1L)),
bor3(lau < 1L, logi_k, v %between% c(-1L, 1L)))
expect_equal(or3s(lav < 9L, logi_d, c %between% c(-1L, 1L)),
bor3(lav < 9L, logi_d, c %between% c(-1L, 1L)))
expect_equal(or3s(law < 0L, , ),
bor3(law < 0L, , ))
expect_equal(or3s(lax < 1L, , ),
bor3(lax < 1L, , ))
expect_equal(or3s(lay < 9L, , ),
bor3(lay < 9L, , ))
expect_equal(or3s(laz < 0L, , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(laz < 0L, , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lba < 1L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lba < 1L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lbb < 9L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lbb < 9L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lbc < 0L, logi_i, ),
bor3(lbc < 0L, logi_i, ))
expect_equal(or3s(lbd < 1L, logi_n, ),
bor3(lbd < 1L, logi_n, ))
expect_equal(or3s(lbe < 9L, logi_a, ),
bor3(lbe < 9L, logi_a, ))
expect_equal(or3s(lbf < 0L, logi_p, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lbf < 0L, logi_p, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lbg < 1L, logi_h, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lbg < 1L, logi_h, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lbh < 9L, logi_b, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lbh < 9L, logi_b, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lbi < 0L, , ),
bor3(lbi < 0L, , ))
expect_equal(or3s(lbj < 1L, , ),
bor3(lbj < 1L, , ))
expect_equal(or3s(lbk < 9L, , ),
bor3(lbk < 9L, , ))
expect_equal(or3s(lbl < 0L, , y %in% 1:4),
bor3(lbl < 0L, , y %in% 1:4))
expect_equal(or3s(lbm < 1L, , h %in% 1:4),
bor3(lbm < 1L, , h %in% 1:4))
expect_equal(or3s(lbn < 9L, , y %in% 1:4),
bor3(lbn < 9L, , y %in% 1:4))
expect_equal(or3s(lbo < 0L, logi_o, ),
bor3(lbo < 0L, logi_o, ))
expect_equal(or3s(lbp < 1L, logi_n, ),
bor3(lbp < 1L, logi_n, ))
expect_equal(or3s(lbq < 9L, logi_j, ),
bor3(lbq < 9L, logi_j, ))
expect_equal(or3s(lbr < 0L, logi_m, e %in% 1:4),
bor3(lbr < 0L, logi_m, e %in% 1:4))
expect_equal(or3s(lbs < 1L, logi_d, k %in% 1:4),
bor3(lbs < 1L, logi_d, k %in% 1:4))
expect_equal(or3s(lbt < 9L, logi_y, i %in% 1:4),
bor3(lbt < 9L, logi_y, i %in% 1:4))
expect_equal(or3s(lbu < 0L, , ),
bor3(lbu < 0L, , ))
expect_equal(or3s(lbv < 1L, , ),
bor3(lbv < 1L, , ))
expect_equal(or3s(lbw < 9L, , ),
bor3(lbw < 9L, , ))
expect_equal(or3s(lbx < 0L, , g < 0L),
bor3(lbx < 0L, , g < 0L))
expect_equal(or3s(lby < 1L, , t < 1L),
bor3(lby < 1L, , t < 1L))
expect_equal(or3s(lbz < 9L, , h < 9L),
bor3(lbz < 9L, , h < 9L))
expect_equal(or3s(lca < 0L, logi_q, ),
bor3(lca < 0L, logi_q, ))
expect_equal(or3s(lcb < 1L, logi_z, ),
bor3(lcb < 1L, logi_z, ))
expect_equal(or3s(lcc < 9L, logi_v, ),
bor3(lcc < 9L, logi_v, ))
expect_equal(or3s(lcd < 0L, logi_x, m < 0L),
bor3(lcd < 0L, logi_x, m < 0L))
expect_equal(or3s(lce < 1L, logi_t, m < 1L),
bor3(lce < 1L, logi_t, m < 1L))
expect_equal(or3s(lcf < 9L, logi_s, n < 9L),
bor3(lcf < 9L, logi_s, n < 9L))
expect_equal(or3s(lcg < 0L, , ),
bor3(lcg < 0L, , ))
expect_equal(or3s(lch < 1L, , ),
bor3(lch < 1L, , ))
expect_equal(or3s(lci < 9L, , ),
bor3(lci < 9L, , ))
expect_equal(or3s(lcj < 0L, , d <= 0L),
bor3(lcj < 0L, , d <= 0L))
expect_equal(or3s(lck < 1L, , h <= 1L),
bor3(lck < 1L, , h <= 1L))
expect_equal(or3s(lcl < 9L, , d <= 9L),
bor3(lcl < 9L, , d <= 9L))
expect_equal(or3s(lcm < 0L, logi_k, ),
bor3(lcm < 0L, logi_k, ))
expect_equal(or3s(lcn < 1L, logi_j, ),
bor3(lcn < 1L, logi_j, ))
expect_equal(or3s(lco < 9L, logi_k, ),
bor3(lco < 9L, logi_k, ))
expect_equal(or3s(lcp < 0L, logi_k, i <= 0L),
bor3(lcp < 0L, logi_k, i <= 0L))
expect_equal(or3s(lcq < 1L, logi_b, s <= 1L),
bor3(lcq < 1L, logi_b, s <= 1L))
expect_equal(or3s(lcr < 9L, logi_i, s <= 9L),
bor3(lcr < 9L, logi_i, s <= 9L))
expect_equal(or3s(lcs < 0L, , ),
bor3(lcs < 0L, , ))
expect_equal(or3s(lct < 1L, , ),
bor3(lct < 1L, , ))
expect_equal(or3s(lcu < 9L, , ),
bor3(lcu < 9L, , ))
expect_equal(or3s(lcv < 0L, , n == 0L),
bor3(lcv < 0L, , n == 0L))
expect_equal(or3s(lcw < 1L, , n == 1L),
bor3(lcw < 1L, , n == 1L))
expect_equal(or3s(lcx < 9L, , d == 9L),
bor3(lcx < 9L, , d == 9L))
expect_equal(or3s(lcy < 0L, logi_m, ),
bor3(lcy < 0L, logi_m, ))
expect_equal(or3s(lcz < 1L, logi_x, ),
bor3(lcz < 1L, logi_x, ))
expect_equal(or3s(lda < 9L, logi_q, ),
bor3(lda < 9L, logi_q, ))
expect_equal(or3s(ldb < 0L, logi_m, b == 0L),
bor3(ldb < 0L, logi_m, b == 0L))
expect_equal(or3s(ldc < 1L, logi_j, o == 1L),
bor3(ldc < 1L, logi_j, o == 1L))
expect_equal(or3s(ldd < 9L, logi_a, h == 9L),
bor3(ldd < 9L, logi_a, h == 9L))
expect_equal(or3s(lde < 0L, , ),
bor3(lde < 0L, , ))
expect_equal(or3s(ldf < 1L, , ),
bor3(ldf < 1L, , ))
expect_equal(or3s(ldg < 9L, , ),
bor3(ldg < 9L, , ))
expect_equal(or3s(ldh < 0L, , c > 0L),
bor3(ldh < 0L, , c > 0L))
expect_equal(or3s(ldi < 1L, , v > 1L),
bor3(ldi < 1L, , v > 1L))
expect_equal(or3s(ldj < 9L, , u > 9L),
bor3(ldj < 9L, , u > 9L))
expect_equal(or3s(ldk < 0L, logi_t, ),
bor3(ldk < 0L, logi_t, ))
expect_equal(or3s(ldl < 1L, logi_a, ),
bor3(ldl < 1L, logi_a, ))
expect_equal(or3s(ldm < 9L, logi_m, ),
bor3(ldm < 9L, logi_m, ))
expect_equal(or3s(ldn < 0L, logi_b, p > 0L),
bor3(ldn < 0L, logi_b, p > 0L))
expect_equal(or3s(ldo < 1L, logi_d, j > 1L),
bor3(ldo < 1L, logi_d, j > 1L))
expect_equal(or3s(ldp < 9L, logi_e, s > 9L),
bor3(ldp < 9L, logi_e, s > 9L))
expect_equal(or3s(ldq < 0L, , ),
bor3(ldq < 0L, , ))
expect_equal(or3s(ldr < 1L, , ),
bor3(ldr < 1L, , ))
expect_equal(or3s(lds < 9L, , ),
bor3(lds < 9L, , ))
expect_equal(or3s(ldt < 0L, , s >= 0L),
bor3(ldt < 0L, , s >= 0L))
expect_equal(or3s(ldu < 1L, , z >= 1L),
bor3(ldu < 1L, , z >= 1L))
expect_equal(or3s(ldv < 9L, , j >= 9L),
bor3(ldv < 9L, , j >= 9L))
expect_equal(or3s(ldw < 0L, logi_f, ),
bor3(ldw < 0L, logi_f, ))
expect_equal(or3s(ldx < 1L, logi_h, ),
bor3(ldx < 1L, logi_h, ))
expect_equal(or3s(ldy < 9L, logi_w, ),
bor3(ldy < 9L, logi_w, ))
expect_equal(or3s(ldz < 0L, logi_x, c >= 0L),
bor3(ldz < 0L, logi_x, c >= 0L))
expect_equal(or3s(lea < 1L, logi_j, d >= 1L),
bor3(lea < 1L, logi_j, d >= 1L))
expect_equal(or3s(leb < 9L, logi_v, s >= 9L),
bor3(leb < 9L, logi_v, s >= 9L))
expect_equal(or3s(lec < 0L, , ),
bor3(lec < 0L, , ))
expect_equal(or3s(led < 1L, , ),
bor3(led < 1L, , ))
expect_equal(or3s(lee < 9L, , ),
bor3(lee < 9L, , ))
expect_equal(or3s(lef < 0L, , logi_e),
bor3(lef < 0L, , logi_e))
expect_equal(or3s(leg < 1L, , logi_i),
bor3(leg < 1L, , logi_i))
expect_equal(or3s(leh < 9L, , logi_f),
bor3(leh < 9L, , logi_f))
expect_equal(or3s(lei < 0L, !logi_a, ),
bor3(lei < 0L, !logi_a, ))
expect_equal(or3s(lej < 1L, !logi_s, ),
bor3(lej < 1L, !logi_s, ))
expect_equal(or3s(lek < 9L, !logi_t, ),
bor3(lek < 9L, !logi_t, ))
expect_equal(or3s(lel < 0L, !logi_r, logi_i),
bor3(lel < 0L, !logi_r, logi_i))
expect_equal(or3s(lem < 1L, !logi_d, logi_j),
bor3(lem < 1L, !logi_d, logi_j))
expect_equal(or3s(len < 9L, !logi_f, logi_g),
bor3(len < 9L, !logi_f, logi_g))
expect_equal(or3s(leo < 0L, , ),
bor3(leo < 0L, , ))
expect_equal(or3s(lep < 1L, , ),
bor3(lep < 1L, , ))
expect_equal(or3s(leq < 9L, , ),
bor3(leq < 9L, , ))
expect_equal(or3s(ler < 0L, , !logi_r),
bor3(ler < 0L, , !logi_r))
expect_equal(or3s(les < 1L, , !logi_q),
bor3(les < 1L, , !logi_q))
expect_equal(or3s(let < 9L, , !logi_d),
bor3(let < 9L, , !logi_d))
expect_equal(or3s(leu < 0L, !logi_k, ),
bor3(leu < 0L, !logi_k, ))
expect_equal(or3s(lev < 1L, !logi_z, ),
bor3(lev < 1L, !logi_z, ))
expect_equal(or3s(lew < 9L, !logi_i, ),
bor3(lew < 9L, !logi_i, ))
expect_equal(or3s(lex < 0L, !logi_l, !logi_f),
bor3(lex < 0L, !logi_l, !logi_f))
expect_equal(or3s(ley < 1L, !logi_d, !logi_p),
bor3(ley < 1L, !logi_d, !logi_p))
expect_equal(or3s(lez < 9L, !logi_b, !logi_u),
bor3(lez < 9L, !logi_b, !logi_u))
expect_equal(or3s(lfa < 0L, , ),
bor3(lfa < 0L, , ))
expect_equal(or3s(lfb < 1L, , ),
bor3(lfb < 1L, , ))
expect_equal(or3s(lfc < 9L, , ),
bor3(lfc < 9L, , ))
expect_equal(or3s(lfd < 0L, , n != 0L),
bor3(lfd < 0L, , n != 0L))
expect_equal(or3s(lfe < 1L, , t != 1L),
bor3(lfe < 1L, , t != 1L))
expect_equal(or3s(lff < 9L, , r != 9L),
bor3(lff < 9L, , r != 9L))
expect_equal(or3s(lfg < 0L, !logi_m, ),
bor3(lfg < 0L, !logi_m, ))
expect_equal(or3s(lfh < 1L, !logi_q, ),
bor3(lfh < 1L, !logi_q, ))
expect_equal(or3s(lfi < 9L, !logi_m, ),
bor3(lfi < 9L, !logi_m, ))
expect_equal(or3s(lfj < 0L, !logi_m, a != 0L),
bor3(lfj < 0L, !logi_m, a != 0L))
expect_equal(or3s(lfk < 1L, !logi_w, k != 1L),
bor3(lfk < 1L, !logi_w, k != 1L))
expect_equal(or3s(lfl < 9L, !logi_o, v != 9L),
bor3(lfl < 9L, !logi_o, v != 9L))
expect_equal(or3s(lfm < 0L, , ),
bor3(lfm < 0L, , ))
expect_equal(or3s(lfn < 1L, , ),
bor3(lfn < 1L, , ))
expect_equal(or3s(lfo < 9L, , ),
bor3(lfo < 9L, , ))
expect_equal(or3s(lfp < 0L, , w %between% c(-1L, 1L)),
bor3(lfp < 0L, , w %between% c(-1L, 1L)))
expect_equal(or3s(lfq < 1L, , l %between% c(-1L, 1L)),
bor3(lfq < 1L, , l %between% c(-1L, 1L)))
expect_equal(or3s(lfr < 9L, , q %between% c(-1L, 1L)),
bor3(lfr < 9L, , q %between% c(-1L, 1L)))
expect_equal(or3s(lfs < 0L, !logi_d, ),
bor3(lfs < 0L, !logi_d, ))
expect_equal(or3s(lft < 1L, !logi_w, ),
bor3(lft < 1L, !logi_w, ))
expect_equal(or3s(lfu < 9L, !logi_p, ),
bor3(lfu < 9L, !logi_p, ))
expect_equal(or3s(lfv < 0L, !logi_c, f %between% c(-1L, 1L)),
bor3(lfv < 0L, !logi_c, f %between% c(-1L, 1L)))
expect_equal(or3s(lfw < 1L, !logi_i, h %between% c(-1L, 1L)),
bor3(lfw < 1L, !logi_i, h %between% c(-1L, 1L)))
expect_equal(or3s(lfx < 9L, !logi_n, f %between% c(-1L, 1L)),
bor3(lfx < 9L, !logi_n, f %between% c(-1L, 1L)))
expect_equal(or3s(lfy < 0L, , ),
bor3(lfy < 0L, , ))
expect_equal(or3s(lfz < 1L, , ),
bor3(lfz < 1L, , ))
expect_equal(or3s(lga < 9L, , ),
bor3(lga < 9L, , ))
expect_equal(or3s(lgb < 0L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lgb < 0L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lgc < 1L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lgc < 1L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lgd < 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lgd < 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lge < 0L, !logi_k, ),
bor3(lge < 0L, !logi_k, ))
expect_equal(or3s(lgf < 1L, !logi_d, ),
bor3(lgf < 1L, !logi_d, ))
expect_equal(or3s(lgg < 9L, !logi_b, ),
bor3(lgg < 9L, !logi_b, ))
expect_equal(or3s(lgh < 0L, !logi_w, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lgh < 0L, !logi_w, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lgi < 1L, !logi_p, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lgi < 1L, !logi_p, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lgj < 9L, !logi_j, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lgj < 9L, !logi_j, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lgk < 0L, , ),
bor3(lgk < 0L, , ))
expect_equal(or3s(lgl < 1L, , ),
bor3(lgl < 1L, , ))
expect_equal(or3s(lgm < 9L, , ),
bor3(lgm < 9L, , ))
expect_equal(or3s(lgn < 0L, , n %in% 1:4),
bor3(lgn < 0L, , n %in% 1:4))
expect_equal(or3s(lgo < 1L, , w %in% 1:4),
bor3(lgo < 1L, , w %in% 1:4))
expect_equal(or3s(lgp < 9L, , k %in% 1:4),
bor3(lgp < 9L, , k %in% 1:4))
expect_equal(or3s(lgq < 0L, !logi_n, ),
bor3(lgq < 0L, !logi_n, ))
expect_equal(or3s(lgr < 1L, !logi_t, ),
bor3(lgr < 1L, !logi_t, ))
expect_equal(or3s(lgs < 9L, !logi_t, ),
bor3(lgs < 9L, !logi_t, ))
expect_equal(or3s(lgt < 0L, !logi_k, q %in% 1:4),
bor3(lgt < 0L, !logi_k, q %in% 1:4))
expect_equal(or3s(lgu < 1L, !logi_i, c %in% 1:4),
bor3(lgu < 1L, !logi_i, c %in% 1:4))
expect_equal(or3s(lgv < 9L, !logi_z, z %in% 1:4),
bor3(lgv < 9L, !logi_z, z %in% 1:4))
expect_equal(or3s(lgw < 0L, , ),
bor3(lgw < 0L, , ))
expect_equal(or3s(lgx < 1L, , ),
bor3(lgx < 1L, , ))
expect_equal(or3s(lgy < 9L, , ),
bor3(lgy < 9L, , ))
expect_equal(or3s(lgz < 0L, , d < 0L),
bor3(lgz < 0L, , d < 0L))
expect_equal(or3s(lha < 1L, , j < 1L),
bor3(lha < 1L, , j < 1L))
expect_equal(or3s(lhb < 9L, , d < 9L),
bor3(lhb < 9L, , d < 9L))
expect_equal(or3s(lhc < 0L, !logi_h, ),
bor3(lhc < 0L, !logi_h, ))
expect_equal(or3s(lhd < 1L, !logi_x, ),
bor3(lhd < 1L, !logi_x, ))
expect_equal(or3s(lhe < 9L, !logi_v, ),
bor3(lhe < 9L, !logi_v, ))
expect_equal(or3s(lhf < 0L, !logi_t, u < 0L),
bor3(lhf < 0L, !logi_t, u < 0L))
expect_equal(or3s(lhg < 1L, !logi_h, o < 1L),
bor3(lhg < 1L, !logi_h, o < 1L))
expect_equal(or3s(lhh < 9L, !logi_i, p < 9L),
bor3(lhh < 9L, !logi_i, p < 9L))
expect_equal(or3s(lhi < 0L, , ),
bor3(lhi < 0L, , ))
expect_equal(or3s(lhj < 1L, , ),
bor3(lhj < 1L, , ))
expect_equal(or3s(lhk < 9L, , ),
bor3(lhk < 9L, , ))
expect_equal(or3s(lhl < 0L, , y <= 0L),
bor3(lhl < 0L, , y <= 0L))
expect_equal(or3s(lhm < 1L, , j <= 1L),
bor3(lhm < 1L, , j <= 1L))
expect_equal(or3s(lhn < 9L, , v <= 9L),
bor3(lhn < 9L, , v <= 9L))
expect_equal(or3s(lho < 0L, !logi_a, ),
bor3(lho < 0L, !logi_a, ))
expect_equal(or3s(lhp < 1L, !logi_v, ),
bor3(lhp < 1L, !logi_v, ))
expect_equal(or3s(lhq < 9L, !logi_r, ),
bor3(lhq < 9L, !logi_r, ))
expect_equal(or3s(lhr < 0L, !logi_k, x <= 0L),
bor3(lhr < 0L, !logi_k, x <= 0L))
expect_equal(or3s(lhs < 1L, !logi_n, x <= 1L),
bor3(lhs < 1L, !logi_n, x <= 1L))
expect_equal(or3s(lht < 9L, !logi_x, b <= 9L),
bor3(lht < 9L, !logi_x, b <= 9L))
expect_equal(or3s(lhu < 0L, , ),
bor3(lhu < 0L, , ))
expect_equal(or3s(lhv < 1L, , ),
bor3(lhv < 1L, , ))
expect_equal(or3s(lhw < 9L, , ),
bor3(lhw < 9L, , ))
expect_equal(or3s(lhx < 0L, , c == 0L),
bor3(lhx < 0L, , c == 0L))
expect_equal(or3s(lhy < 1L, , g == 1L),
bor3(lhy < 1L, , g == 1L))
expect_equal(or3s(lhz < 9L, , e == 9L),
bor3(lhz < 9L, , e == 9L))
expect_equal(or3s(lia < 0L, !logi_t, ),
bor3(lia < 0L, !logi_t, ))
expect_equal(or3s(lib < 1L, !logi_c, ),
bor3(lib < 1L, !logi_c, ))
expect_equal(or3s(lic < 9L, !logi_p, ),
bor3(lic < 9L, !logi_p, ))
expect_equal(or3s(lid < 0L, !logi_i, m == 0L),
bor3(lid < 0L, !logi_i, m == 0L))
expect_equal(or3s(lie < 1L, !logi_a, b == 1L),
bor3(lie < 1L, !logi_a, b == 1L))
expect_equal(or3s(lif < 9L, !logi_u, o == 9L),
bor3(lif < 9L, !logi_u, o == 9L))
expect_equal(or3s(lig < 0L, , ),
bor3(lig < 0L, , ))
expect_equal(or3s(lih < 1L, , ),
bor3(lih < 1L, , ))
expect_equal(or3s(lii < 9L, , ),
bor3(lii < 9L, , ))
expect_equal(or3s(lij < 0L, , q > 0L),
bor3(lij < 0L, , q > 0L))
expect_equal(or3s(lik < 1L, , u > 1L),
bor3(lik < 1L, , u > 1L))
expect_equal(or3s(lil < 9L, , u > 9L),
bor3(lil < 9L, , u > 9L))
expect_equal(or3s(lim < 0L, !logi_j, ),
bor3(lim < 0L, !logi_j, ))
expect_equal(or3s(lin < 1L, !logi_s, ),
bor3(lin < 1L, !logi_s, ))
expect_equal(or3s(lio < 9L, !logi_k, ),
bor3(lio < 9L, !logi_k, ))
expect_equal(or3s(lip < 0L, !logi_w, s > 0L),
bor3(lip < 0L, !logi_w, s > 0L))
expect_equal(or3s(liq < 1L, !logi_v, o > 1L),
bor3(liq < 1L, !logi_v, o > 1L))
expect_equal(or3s(lir < 9L, !logi_g, a > 9L),
bor3(lir < 9L, !logi_g, a > 9L))
expect_equal(or3s(lis < 0L, , ),
bor3(lis < 0L, , ))
expect_equal(or3s(lit < 1L, , ),
bor3(lit < 1L, , ))
expect_equal(or3s(liu < 9L, , ),
bor3(liu < 9L, , ))
expect_equal(or3s(liv < 0L, , v >= 0L),
bor3(liv < 0L, , v >= 0L))
expect_equal(or3s(liw < 1L, , a >= 1L),
bor3(liw < 1L, , a >= 1L))
expect_equal(or3s(lix < 9L, , o >= 9L),
bor3(lix < 9L, , o >= 9L))
expect_equal(or3s(liy < 0L, !logi_h, ),
bor3(liy < 0L, !logi_h, ))
expect_equal(or3s(liz < 1L, !logi_x, ),
bor3(liz < 1L, !logi_x, ))
expect_equal(or3s(lja < 9L, !logi_h, ),
bor3(lja < 9L, !logi_h, ))
expect_equal(or3s(ljb < 0L, !logi_n, p >= 0L),
bor3(ljb < 0L, !logi_n, p >= 0L))
expect_equal(or3s(ljc < 1L, !logi_u, i >= 1L),
bor3(ljc < 1L, !logi_u, i >= 1L))
expect_equal(or3s(ljd < 9L, !logi_x, k >= 9L),
bor3(ljd < 9L, !logi_x, k >= 9L))
expect_equal(or3s(lje < 0L, , ),
bor3(lje < 0L, , ))
expect_equal(or3s(ljf < 1L, , ),
bor3(ljf < 1L, , ))
expect_equal(or3s(ljg < 9L, , ),
bor3(ljg < 9L, , ))
expect_equal(or3s(ljh < 0L, , logi_l),
bor3(ljh < 0L, , logi_l))
expect_equal(or3s(lji < 1L, , logi_v),
bor3(lji < 1L, , logi_v))
expect_equal(or3s(ljj < 9L, , logi_b),
bor3(ljj < 9L, , logi_b))
expect_equal(or3s(ljk < 0L, c != 0L, ),
bor3(ljk < 0L, c != 0L, ))
expect_equal(or3s(ljl < 1L, s != 1L, ),
bor3(ljl < 1L, s != 1L, ))
expect_equal(or3s(ljm < 9L, d != 9L, ),
bor3(ljm < 9L, d != 9L, ))
expect_equal(or3s(ljn < 0L, z != 0L, logi_u),
bor3(ljn < 0L, z != 0L, logi_u))
expect_equal(or3s(ljo < 1L, k != 1L, logi_x),
bor3(ljo < 1L, k != 1L, logi_x))
expect_equal(or3s(ljp < 9L, x != 9L, logi_v),
bor3(ljp < 9L, x != 9L, logi_v))
expect_equal(or3s(ljq < 0L, , ),
bor3(ljq < 0L, , ))
expect_equal(or3s(ljr < 1L, , ),
bor3(ljr < 1L, , ))
expect_equal(or3s(ljs < 9L, , ),
bor3(ljs < 9L, , ))
expect_equal(or3s(ljt < 0L, , !logi_b),
bor3(ljt < 0L, , !logi_b))
expect_equal(or3s(lju < 1L, , !logi_p),
bor3(lju < 1L, , !logi_p))
expect_equal(or3s(ljv < 9L, , !logi_w),
bor3(ljv < 9L, , !logi_w))
expect_equal(or3s(ljw < 0L, q != 0L, ),
bor3(ljw < 0L, q != 0L, ))
expect_equal(or3s(ljx < 1L, x != 1L, ),
bor3(ljx < 1L, x != 1L, ))
expect_equal(or3s(ljy < 9L, q != 9L, ),
bor3(ljy < 9L, q != 9L, ))
expect_equal(or3s(ljz < 0L, a != 0L, !logi_t),
bor3(ljz < 0L, a != 0L, !logi_t))
expect_equal(or3s(lka < 1L, f != 1L, !logi_d),
bor3(lka < 1L, f != 1L, !logi_d))
expect_equal(or3s(lkb < 9L, o != 9L, !logi_o),
bor3(lkb < 9L, o != 9L, !logi_o))
expect_equal(or3s(lkc < 0L, , ),
bor3(lkc < 0L, , ))
expect_equal(or3s(lkd < 1L, , ),
bor3(lkd < 1L, , ))
expect_equal(or3s(lke < 9L, , ),
bor3(lke < 9L, , ))
expect_equal(or3s(lkf < 0L, , x != 0L),
bor3(lkf < 0L, , x != 0L))
expect_equal(or3s(lkg < 1L, , z != 1L),
bor3(lkg < 1L, , z != 1L))
expect_equal(or3s(lkh < 9L, , e != 9L),
bor3(lkh < 9L, , e != 9L))
expect_equal(or3s(lki < 0L, k != 0L, ),
bor3(lki < 0L, k != 0L, ))
expect_equal(or3s(lkj < 1L, s != 1L, ),
bor3(lkj < 1L, s != 1L, ))
expect_equal(or3s(lkk < 9L, j != 9L, ),
bor3(lkk < 9L, j != 9L, ))
expect_equal(or3s(lkl < 0L, e != 0L, e != 0L),
bor3(lkl < 0L, e != 0L, e != 0L))
expect_equal(or3s(lkm < 1L, k != 1L, l != 1L),
bor3(lkm < 1L, k != 1L, l != 1L))
expect_equal(or3s(lkn < 9L, e != 9L, e != 9L),
bor3(lkn < 9L, e != 9L, e != 9L))
expect_equal(or3s(lko < 0L, , ),
bor3(lko < 0L, , ))
expect_equal(or3s(lkp < 1L, , ),
bor3(lkp < 1L, , ))
expect_equal(or3s(lkq < 9L, , ),
bor3(lkq < 9L, , ))
expect_equal(or3s(lkr < 0L, , z %between% c(-1L, 1L)),
bor3(lkr < 0L, , z %between% c(-1L, 1L)))
expect_equal(or3s(lks < 1L, , j %between% c(-1L, 1L)),
bor3(lks < 1L, , j %between% c(-1L, 1L)))
expect_equal(or3s(lkt < 9L, , s %between% c(-1L, 1L)),
bor3(lkt < 9L, , s %between% c(-1L, 1L)))
expect_equal(or3s(lku < 0L, s != 0L, ),
bor3(lku < 0L, s != 0L, ))
expect_equal(or3s(lkv < 1L, c != 1L, ),
bor3(lkv < 1L, c != 1L, ))
expect_equal(or3s(lkw < 9L, m != 9L, ),
bor3(lkw < 9L, m != 9L, ))
expect_equal(or3s(lkx < 0L, q != 0L, p %between% c(-1L, 1L)),
bor3(lkx < 0L, q != 0L, p %between% c(-1L, 1L)))
expect_equal(or3s(lky < 1L, v != 1L, d %between% c(-1L, 1L)),
bor3(lky < 1L, v != 1L, d %between% c(-1L, 1L)))
expect_equal(or3s(lkz < 9L, b != 9L, q %between% c(-1L, 1L)),
bor3(lkz < 9L, b != 9L, q %between% c(-1L, 1L)))
expect_equal(or3s(lla < 0L, , ),
bor3(lla < 0L, , ))
expect_equal(or3s(llb < 1L, , ),
bor3(llb < 1L, , ))
expect_equal(or3s(llc < 9L, , ),
bor3(llc < 9L, , ))
expect_equal(or3s(lld < 0L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lld < 0L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lle < 1L, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lle < 1L, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(llf < 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(llf < 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(llg < 0L, b != 0L, ),
bor3(llg < 0L, b != 0L, ))
expect_equal(or3s(llh < 1L, k != 1L, ),
bor3(llh < 1L, k != 1L, ))
expect_equal(or3s(lli < 9L, u != 9L, ),
bor3(lli < 9L, u != 9L, ))
expect_equal(or3s(llj < 0L, p != 0L, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(llj < 0L, p != 0L, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(llk < 1L, c != 1L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(llk < 1L, c != 1L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lll < 9L, q != 9L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lll < 9L, q != 9L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(llm < 0L, , ),
bor3(llm < 0L, , ))
expect_equal(or3s(lln < 1L, , ),
bor3(lln < 1L, , ))
expect_equal(or3s(llo < 9L, , ),
bor3(llo < 9L, , ))
expect_equal(or3s(llp < 0L, , n %in% 1:4),
bor3(llp < 0L, , n %in% 1:4))
expect_equal(or3s(llq < 1L, , x %in% 1:4),
bor3(llq < 1L, , x %in% 1:4))
expect_equal(or3s(llr < 9L, , p %in% 1:4),
bor3(llr < 9L, , p %in% 1:4))
expect_equal(or3s(lls < 0L, b != 0L, ),
bor3(lls < 0L, b != 0L, ))
expect_equal(or3s(llt < 1L, q != 1L, ),
bor3(llt < 1L, q != 1L, ))
expect_equal(or3s(llu < 9L, y != 9L, ),
bor3(llu < 9L, y != 9L, ))
expect_equal(or3s(llv < 0L, t != 0L, y %in% 1:4),
bor3(llv < 0L, t != 0L, y %in% 1:4))
expect_equal(or3s(llw < 1L, t != 1L, a %in% 1:4),
bor3(llw < 1L, t != 1L, a %in% 1:4))
expect_equal(or3s(llx < 9L, a != 9L, h %in% 1:4),
bor3(llx < 9L, a != 9L, h %in% 1:4))
expect_equal(or3s(lly < 0L, , ),
bor3(lly < 0L, , ))
expect_equal(or3s(llz < 1L, , ),
bor3(llz < 1L, , ))
expect_equal(or3s(lma < 9L, , ),
bor3(lma < 9L, , ))
expect_equal(or3s(lmb < 0L, , s < 0L),
bor3(lmb < 0L, , s < 0L))
expect_equal(or3s(lmc < 1L, , d < 1L),
bor3(lmc < 1L, , d < 1L))
expect_equal(or3s(lmd < 9L, , k < 9L),
bor3(lmd < 9L, , k < 9L))
expect_equal(or3s(lme < 0L, g != 0L, ),
bor3(lme < 0L, g != 0L, ))
expect_equal(or3s(lmf < 1L, i != 1L, ),
bor3(lmf < 1L, i != 1L, ))
expect_equal(or3s(lmg < 9L, q != 9L, ),
bor3(lmg < 9L, q != 9L, ))
expect_equal(or3s(lmh < 0L, n != 0L, h < 0L),
bor3(lmh < 0L, n != 0L, h < 0L))
expect_equal(or3s(lmi < 1L, w != 1L, h < 1L),
bor3(lmi < 1L, w != 1L, h < 1L))
expect_equal(or3s(lmj < 9L, n != 9L, k < 9L),
bor3(lmj < 9L, n != 9L, k < 9L))
expect_equal(or3s(lmk < 0L, , ),
bor3(lmk < 0L, , ))
expect_equal(or3s(lml < 1L, , ),
bor3(lml < 1L, , ))
expect_equal(or3s(lmm < 9L, , ),
bor3(lmm < 9L, , ))
expect_equal(or3s(lmn < 0L, , u <= 0L),
bor3(lmn < 0L, , u <= 0L))
expect_equal(or3s(lmo < 1L, , e <= 1L),
bor3(lmo < 1L, , e <= 1L))
expect_equal(or3s(lmp < 9L, , e <= 9L),
bor3(lmp < 9L, , e <= 9L))
expect_equal(or3s(lmq < 0L, l != 0L, ),
bor3(lmq < 0L, l != 0L, ))
expect_equal(or3s(lmr < 1L, x != 1L, ),
bor3(lmr < 1L, x != 1L, ))
expect_equal(or3s(lms < 9L, r != 9L, ),
bor3(lms < 9L, r != 9L, ))
expect_equal(or3s(lmt < 0L, i != 0L, i <= 0L),
bor3(lmt < 0L, i != 0L, i <= 0L))
expect_equal(or3s(lmu < 1L, r != 1L, m <= 1L),
bor3(lmu < 1L, r != 1L, m <= 1L))
expect_equal(or3s(lmv < 9L, v != 9L, h <= 9L),
bor3(lmv < 9L, v != 9L, h <= 9L))
expect_equal(or3s(lmw < 0L, , ),
bor3(lmw < 0L, , ))
expect_equal(or3s(lmx < 1L, , ),
bor3(lmx < 1L, , ))
expect_equal(or3s(lmy < 9L, , ),
bor3(lmy < 9L, , ))
expect_equal(or3s(lmz < 0L, , c == 0L),
bor3(lmz < 0L, , c == 0L))
expect_equal(or3s(lna < 1L, , e == 1L),
bor3(lna < 1L, , e == 1L))
expect_equal(or3s(lnb < 9L, , q == 9L),
bor3(lnb < 9L, , q == 9L))
expect_equal(or3s(lnc < 0L, z != 0L, ),
bor3(lnc < 0L, z != 0L, ))
expect_equal(or3s(lnd < 1L, y != 1L, ),
bor3(lnd < 1L, y != 1L, ))
expect_equal(or3s(lne < 9L, a != 9L, ),
bor3(lne < 9L, a != 9L, ))
expect_equal(or3s(lnf < 0L, o != 0L, s == 0L),
bor3(lnf < 0L, o != 0L, s == 0L))
expect_equal(or3s(lng < 1L, m != 1L, l == 1L),
bor3(lng < 1L, m != 1L, l == 1L))
expect_equal(or3s(lnh < 9L, n != 9L, u == 9L),
bor3(lnh < 9L, n != 9L, u == 9L))
expect_equal(or3s(lni < 0L, , ),
bor3(lni < 0L, , ))
expect_equal(or3s(lnj < 1L, , ),
bor3(lnj < 1L, , ))
expect_equal(or3s(lnk < 9L, , ),
bor3(lnk < 9L, , ))
expect_equal(or3s(lnl < 0L, , t > 0L),
bor3(lnl < 0L, , t > 0L))
expect_equal(or3s(lnm < 1L, , g > 1L),
bor3(lnm < 1L, , g > 1L))
expect_equal(or3s(lnn < 9L, , o > 9L),
bor3(lnn < 9L, , o > 9L))
expect_equal(or3s(lno < 0L, z != 0L, ),
bor3(lno < 0L, z != 0L, ))
expect_equal(or3s(lnp < 1L, p != 1L, ),
bor3(lnp < 1L, p != 1L, ))
expect_equal(or3s(lnq < 9L, q != 9L, ),
bor3(lnq < 9L, q != 9L, ))
expect_equal(or3s(lnr < 0L, s != 0L, g > 0L),
bor3(lnr < 0L, s != 0L, g > 0L))
expect_equal(or3s(lns < 1L, p != 1L, v > 1L),
bor3(lns < 1L, p != 1L, v > 1L))
expect_equal(or3s(lnt < 9L, l != 9L, t > 9L),
bor3(lnt < 9L, l != 9L, t > 9L))
expect_equal(or3s(lnu < 0L, , ),
bor3(lnu < 0L, , ))
expect_equal(or3s(lnv < 1L, , ),
bor3(lnv < 1L, , ))
expect_equal(or3s(lnw < 9L, , ),
bor3(lnw < 9L, , ))
expect_equal(or3s(lnx < 0L, , c >= 0L),
bor3(lnx < 0L, , c >= 0L))
expect_equal(or3s(lny < 1L, , l >= 1L),
bor3(lny < 1L, , l >= 1L))
expect_equal(or3s(lnz < 9L, , m >= 9L),
bor3(lnz < 9L, , m >= 9L))
expect_equal(or3s(loa < 0L, b != 0L, ),
bor3(loa < 0L, b != 0L, ))
expect_equal(or3s(lob < 1L, u != 1L, ),
bor3(lob < 1L, u != 1L, ))
expect_equal(or3s(loc < 9L, x != 9L, ),
bor3(loc < 9L, x != 9L, ))
expect_equal(or3s(lod < 0L, m != 0L, c >= 0L),
bor3(lod < 0L, m != 0L, c >= 0L))
expect_equal(or3s(loe < 1L, o != 1L, m >= 1L),
bor3(loe < 1L, o != 1L, m >= 1L))
expect_equal(or3s(lof < 9L, p != 9L, i >= 9L),
bor3(lof < 9L, p != 9L, i >= 9L))
expect_equal(or3s(log < 0L, , ),
bor3(log < 0L, , ))
expect_equal(or3s(loh < 1L, , ),
bor3(loh < 1L, , ))
expect_equal(or3s(loi < 9L, , ),
bor3(loi < 9L, , ))
expect_equal(or3s(loj < 0L, , logi_l),
bor3(loj < 0L, , logi_l))
expect_equal(or3s(lok < 1L, , logi_h),
bor3(lok < 1L, , logi_h))
expect_equal(or3s(lol < 9L, , logi_n),
bor3(lol < 9L, , logi_n))
expect_equal(or3s(lom < 0L, o %between% c(-1L, 1L), ),
bor3(lom < 0L, o %between% c(-1L, 1L), ))
expect_equal(or3s(lon < 1L, p %between% c(-1L, 1L), ),
bor3(lon < 1L, p %between% c(-1L, 1L), ))
expect_equal(or3s(loo < 9L, j %between% c(-1L, 1L), ),
bor3(loo < 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(lop < 0L, f %between% c(-1L, 1L), logi_g),
bor3(lop < 0L, f %between% c(-1L, 1L), logi_g))
expect_equal(or3s(loq < 1L, i %between% c(-1L, 1L), logi_x),
bor3(loq < 1L, i %between% c(-1L, 1L), logi_x))
expect_equal(or3s(lor < 9L, z %between% c(-1L, 1L), logi_u),
bor3(lor < 9L, z %between% c(-1L, 1L), logi_u))
expect_equal(or3s(los < 0L, , ),
bor3(los < 0L, , ))
expect_equal(or3s(lot < 1L, , ),
bor3(lot < 1L, , ))
expect_equal(or3s(lou < 9L, , ),
bor3(lou < 9L, , ))
expect_equal(or3s(lov < 0L, , !logi_u),
bor3(lov < 0L, , !logi_u))
expect_equal(or3s(low < 1L, , !logi_c),
bor3(low < 1L, , !logi_c))
expect_equal(or3s(lox < 9L, , !logi_i),
bor3(lox < 9L, , !logi_i))
expect_equal(or3s(loy < 0L, d %between% c(-1L, 1L), ),
bor3(loy < 0L, d %between% c(-1L, 1L), ))
expect_equal(or3s(loz < 1L, n %between% c(-1L, 1L), ),
bor3(loz < 1L, n %between% c(-1L, 1L), ))
expect_equal(or3s(lpa < 9L, z %between% c(-1L, 1L), ),
bor3(lpa < 9L, z %between% c(-1L, 1L), ))
expect_equal(or3s(lpb < 0L, j %between% c(-1L, 1L), !logi_f),
bor3(lpb < 0L, j %between% c(-1L, 1L), !logi_f))
expect_equal(or3s(lpc < 1L, z %between% c(-1L, 1L), !logi_d),
bor3(lpc < 1L, z %between% c(-1L, 1L), !logi_d))
expect_equal(or3s(lpd < 9L, t %between% c(-1L, 1L), !logi_h),
bor3(lpd < 9L, t %between% c(-1L, 1L), !logi_h))
expect_equal(or3s(lpe < 0L, , ),
bor3(lpe < 0L, , ))
expect_equal(or3s(lpf < 1L, , ),
bor3(lpf < 1L, , ))
expect_equal(or3s(lpg < 9L, , ),
bor3(lpg < 9L, , ))
expect_equal(or3s(lph < 0L, , a != 0L),
bor3(lph < 0L, , a != 0L))
expect_equal(or3s(lpi < 1L, , m != 1L),
bor3(lpi < 1L, , m != 1L))
expect_equal(or3s(lpj < 9L, , o != 9L),
bor3(lpj < 9L, , o != 9L))
expect_equal(or3s(lpk < 0L, g %between% c(-1L, 1L), ),
bor3(lpk < 0L, g %between% c(-1L, 1L), ))
expect_equal(or3s(lpl < 1L, o %between% c(-1L, 1L), ),
bor3(lpl < 1L, o %between% c(-1L, 1L), ))
expect_equal(or3s(lpm < 9L, q %between% c(-1L, 1L), ),
bor3(lpm < 9L, q %between% c(-1L, 1L), ))
expect_equal(or3s(lpn < 0L, u %between% c(-1L, 1L), c != 0L),
bor3(lpn < 0L, u %between% c(-1L, 1L), c != 0L))
expect_equal(or3s(lpo < 1L, w %between% c(-1L, 1L), k != 1L),
bor3(lpo < 1L, w %between% c(-1L, 1L), k != 1L))
expect_equal(or3s(lpp < 9L, b %between% c(-1L, 1L), h != 9L),
bor3(lpp < 9L, b %between% c(-1L, 1L), h != 9L))
expect_equal(or3s(lpq < 0L, , ),
bor3(lpq < 0L, , ))
expect_equal(or3s(lpr < 1L, , ),
bor3(lpr < 1L, , ))
expect_equal(or3s(lps < 9L, , ),
bor3(lps < 9L, , ))
expect_equal(or3s(lpt < 0L, , j %between% c(-1L, 1L)),
bor3(lpt < 0L, , j %between% c(-1L, 1L)))
expect_equal(or3s(lpu < 1L, , e %between% c(-1L, 1L)),
bor3(lpu < 1L, , e %between% c(-1L, 1L)))
expect_equal(or3s(lpv < 9L, , q %between% c(-1L, 1L)),
bor3(lpv < 9L, , q %between% c(-1L, 1L)))
expect_equal(or3s(lpw < 0L, q %between% c(-1L, 1L), ),
bor3(lpw < 0L, q %between% c(-1L, 1L), ))
expect_equal(or3s(lpx < 1L, e %between% c(-1L, 1L), ),
bor3(lpx < 1L, e %between% c(-1L, 1L), ))
expect_equal(or3s(lpy < 9L, l %between% c(-1L, 1L), ),
bor3(lpy < 9L, l %between% c(-1L, 1L), ))
expect_equal(or3s(lpz < 0L, l %between% c(-1L, 1L), j %between% c(-1L, 1L)),
bor3(lpz < 0L, l %between% c(-1L, 1L), j %between% c(-1L, 1L)))
expect_equal(or3s(lqa < 1L, w %between% c(-1L, 1L), s %between% c(-1L, 1L)),
bor3(lqa < 1L, w %between% c(-1L, 1L), s %between% c(-1L, 1L)))
expect_equal(or3s(lqb < 9L, t %between% c(-1L, 1L), z %between% c(-1L, 1L)),
bor3(lqb < 9L, t %between% c(-1L, 1L), z %between% c(-1L, 1L)))
expect_equal(or3s(lqc < 0L, , ),
bor3(lqc < 0L, , ))
expect_equal(or3s(lqd < 1L, , ),
bor3(lqd < 1L, , ))
expect_equal(or3s(lqe < 9L, , ),
bor3(lqe < 9L, , ))
expect_equal(or3s(lqf < 0L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lqf < 0L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lqg < 1L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lqg < 1L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lqh < 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lqh < 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lqi < 0L, q %between% c(-1L, 1L), ),
bor3(lqi < 0L, q %between% c(-1L, 1L), ))
expect_equal(or3s(lqj < 1L, f %between% c(-1L, 1L), ),
bor3(lqj < 1L, f %between% c(-1L, 1L), ))
expect_equal(or3s(lqk < 9L, u %between% c(-1L, 1L), ),
bor3(lqk < 9L, u %between% c(-1L, 1L), ))
expect_equal(or3s(lql < 0L, a %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lql < 0L, a %between% c(-1L, 1L), t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lqm < 1L, v %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lqm < 1L, v %between% c(-1L, 1L), b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lqn < 9L, n %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lqn < 9L, n %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lqo < 0L, , ),
bor3(lqo < 0L, , ))
expect_equal(or3s(lqp < 1L, , ),
bor3(lqp < 1L, , ))
expect_equal(or3s(lqq < 9L, , ),
bor3(lqq < 9L, , ))
expect_equal(or3s(lqr < 0L, , h %in% 1:4),
bor3(lqr < 0L, , h %in% 1:4))
expect_equal(or3s(lqs < 1L, , d %in% 1:4),
bor3(lqs < 1L, , d %in% 1:4))
expect_equal(or3s(lqt < 9L, , j %in% 1:4),
bor3(lqt < 9L, , j %in% 1:4))
expect_equal(or3s(lqu < 0L, d %between% c(-1L, 1L), ),
bor3(lqu < 0L, d %between% c(-1L, 1L), ))
expect_equal(or3s(lqv < 1L, v %between% c(-1L, 1L), ),
bor3(lqv < 1L, v %between% c(-1L, 1L), ))
expect_equal(or3s(lqw < 9L, b %between% c(-1L, 1L), ),
bor3(lqw < 9L, b %between% c(-1L, 1L), ))
expect_equal(or3s(lqx < 0L, y %between% c(-1L, 1L), b %in% 1:4),
bor3(lqx < 0L, y %between% c(-1L, 1L), b %in% 1:4))
expect_equal(or3s(lqy < 1L, j %between% c(-1L, 1L), a %in% 1:4),
bor3(lqy < 1L, j %between% c(-1L, 1L), a %in% 1:4))
expect_equal(or3s(lqz < 9L, j %between% c(-1L, 1L), l %in% 1:4),
bor3(lqz < 9L, j %between% c(-1L, 1L), l %in% 1:4))
expect_equal(or3s(lra < 0L, , ),
bor3(lra < 0L, , ))
expect_equal(or3s(lrb < 1L, , ),
bor3(lrb < 1L, , ))
expect_equal(or3s(lrc < 9L, , ),
bor3(lrc < 9L, , ))
expect_equal(or3s(lrd < 0L, , e < 0L),
bor3(lrd < 0L, , e < 0L))
expect_equal(or3s(lre < 1L, , y < 1L),
bor3(lre < 1L, , y < 1L))
expect_equal(or3s(lrf < 9L, , m < 9L),
bor3(lrf < 9L, , m < 9L))
expect_equal(or3s(lrg < 0L, c %between% c(-1L, 1L), ),
bor3(lrg < 0L, c %between% c(-1L, 1L), ))
expect_equal(or3s(lrh < 1L, r %between% c(-1L, 1L), ),
bor3(lrh < 1L, r %between% c(-1L, 1L), ))
expect_equal(or3s(lri < 9L, j %between% c(-1L, 1L), ),
bor3(lri < 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(lrj < 0L, z %between% c(-1L, 1L), j < 0L),
bor3(lrj < 0L, z %between% c(-1L, 1L), j < 0L))
expect_equal(or3s(lrk < 1L, x %between% c(-1L, 1L), h < 1L),
bor3(lrk < 1L, x %between% c(-1L, 1L), h < 1L))
expect_equal(or3s(lrl < 9L, s %between% c(-1L, 1L), i < 9L),
bor3(lrl < 9L, s %between% c(-1L, 1L), i < 9L))
expect_equal(or3s(lrm < 0L, , ),
bor3(lrm < 0L, , ))
expect_equal(or3s(lrn < 1L, , ),
bor3(lrn < 1L, , ))
expect_equal(or3s(lro < 9L, , ),
bor3(lro < 9L, , ))
expect_equal(or3s(lrp < 0L, , r <= 0L),
bor3(lrp < 0L, , r <= 0L))
expect_equal(or3s(lrq < 1L, , d <= 1L),
bor3(lrq < 1L, , d <= 1L))
expect_equal(or3s(lrr < 9L, , v <= 9L),
bor3(lrr < 9L, , v <= 9L))
expect_equal(or3s(lrs < 0L, h %between% c(-1L, 1L), ),
bor3(lrs < 0L, h %between% c(-1L, 1L), ))
expect_equal(or3s(lrt < 1L, y %between% c(-1L, 1L), ),
bor3(lrt < 1L, y %between% c(-1L, 1L), ))
expect_equal(or3s(lru < 9L, b %between% c(-1L, 1L), ),
bor3(lru < 9L, b %between% c(-1L, 1L), ))
expect_equal(or3s(lrv < 0L, o %between% c(-1L, 1L), l <= 0L),
bor3(lrv < 0L, o %between% c(-1L, 1L), l <= 0L))
expect_equal(or3s(lrw < 1L, q %between% c(-1L, 1L), o <= 1L),
bor3(lrw < 1L, q %between% c(-1L, 1L), o <= 1L))
expect_equal(or3s(lrx < 9L, y %between% c(-1L, 1L), h <= 9L),
bor3(lrx < 9L, y %between% c(-1L, 1L), h <= 9L))
expect_equal(or3s(lry < 0L, , ),
bor3(lry < 0L, , ))
expect_equal(or3s(lrz < 1L, , ),
bor3(lrz < 1L, , ))
expect_equal(or3s(lsa < 9L, , ),
bor3(lsa < 9L, , ))
expect_equal(or3s(lsb < 0L, , u == 0L),
bor3(lsb < 0L, , u == 0L))
expect_equal(or3s(lsc < 1L, , k == 1L),
bor3(lsc < 1L, , k == 1L))
expect_equal(or3s(lsd < 9L, , i == 9L),
bor3(lsd < 9L, , i == 9L))
expect_equal(or3s(lse < 0L, j %between% c(-1L, 1L), ),
bor3(lse < 0L, j %between% c(-1L, 1L), ))
expect_equal(or3s(lsf < 1L, g %between% c(-1L, 1L), ),
bor3(lsf < 1L, g %between% c(-1L, 1L), ))
expect_equal(or3s(lsg < 9L, w %between% c(-1L, 1L), ),
bor3(lsg < 9L, w %between% c(-1L, 1L), ))
expect_equal(or3s(lsh < 0L, s %between% c(-1L, 1L), c == 0L),
bor3(lsh < 0L, s %between% c(-1L, 1L), c == 0L))
expect_equal(or3s(lsi < 1L, q %between% c(-1L, 1L), q == 1L),
bor3(lsi < 1L, q %between% c(-1L, 1L), q == 1L))
expect_equal(or3s(lsj < 9L, y %between% c(-1L, 1L), w == 9L),
bor3(lsj < 9L, y %between% c(-1L, 1L), w == 9L))
expect_equal(or3s(lsk < 0L, , ),
bor3(lsk < 0L, , ))
expect_equal(or3s(lsl < 1L, , ),
bor3(lsl < 1L, , ))
expect_equal(or3s(lsm < 9L, , ),
bor3(lsm < 9L, , ))
expect_equal(or3s(lsn < 0L, , n > 0L),
bor3(lsn < 0L, , n > 0L))
expect_equal(or3s(lso < 1L, , c > 1L),
bor3(lso < 1L, , c > 1L))
expect_equal(or3s(lsp < 9L, , e > 9L),
bor3(lsp < 9L, , e > 9L))
expect_equal(or3s(lsq < 0L, r %between% c(-1L, 1L), ),
bor3(lsq < 0L, r %between% c(-1L, 1L), ))
expect_equal(or3s(lsr < 1L, e %between% c(-1L, 1L), ),
bor3(lsr < 1L, e %between% c(-1L, 1L), ))
expect_equal(or3s(lss < 9L, e %between% c(-1L, 1L), ),
bor3(lss < 9L, e %between% c(-1L, 1L), ))
expect_equal(or3s(lst < 0L, r %between% c(-1L, 1L), q > 0L),
bor3(lst < 0L, r %between% c(-1L, 1L), q > 0L))
expect_equal(or3s(lsu < 1L, p %between% c(-1L, 1L), o > 1L),
bor3(lsu < 1L, p %between% c(-1L, 1L), o > 1L))
expect_equal(or3s(lsv < 9L, w %between% c(-1L, 1L), m > 9L),
bor3(lsv < 9L, w %between% c(-1L, 1L), m > 9L))
expect_equal(or3s(lsw < 0L, , ),
bor3(lsw < 0L, , ))
expect_equal(or3s(lsx < 1L, , ),
bor3(lsx < 1L, , ))
expect_equal(or3s(lsy < 9L, , ),
bor3(lsy < 9L, , ))
expect_equal(or3s(lsz < 0L, , k >= 0L),
bor3(lsz < 0L, , k >= 0L))
expect_equal(or3s(lta < 1L, , f >= 1L),
bor3(lta < 1L, , f >= 1L))
expect_equal(or3s(ltb < 9L, , g >= 9L),
bor3(ltb < 9L, , g >= 9L))
expect_equal(or3s(ltc < 0L, j %between% c(-1L, 1L), ),
bor3(ltc < 0L, j %between% c(-1L, 1L), ))
expect_equal(or3s(ltd < 1L, l %between% c(-1L, 1L), ),
bor3(ltd < 1L, l %between% c(-1L, 1L), ))
expect_equal(or3s(lte < 9L, z %between% c(-1L, 1L), ),
bor3(lte < 9L, z %between% c(-1L, 1L), ))
expect_equal(or3s(ltf < 0L, t %between% c(-1L, 1L), f >= 0L),
bor3(ltf < 0L, t %between% c(-1L, 1L), f >= 0L))
expect_equal(or3s(ltg < 1L, o %between% c(-1L, 1L), j >= 1L),
bor3(ltg < 1L, o %between% c(-1L, 1L), j >= 1L))
expect_equal(or3s(lth < 9L, h %between% c(-1L, 1L), o >= 9L),
bor3(lth < 9L, h %between% c(-1L, 1L), o >= 9L))
expect_equal(or3s(lti < 0L, , ),
bor3(lti < 0L, , ))
expect_equal(or3s(ltj < 1L, , ),
bor3(ltj < 1L, , ))
expect_equal(or3s(ltk < 9L, , ),
bor3(ltk < 9L, , ))
expect_equal(or3s(ltl < 0L, , logi_n),
bor3(ltl < 0L, , logi_n))
expect_equal(or3s(ltm < 1L, , logi_g),
bor3(ltm < 1L, , logi_g))
expect_equal(or3s(ltn < 9L, , logi_w),
bor3(ltn < 9L, , logi_w))
expect_equal(or3s(lto < 0L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lto < 0L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ltp < 1L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ltp < 1L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ltq < 9L, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ltq < 9L, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ltr < 0L, k %in% c(4L, -3L, 2L, 7L, 8L), logi_e),
bor3(ltr < 0L, k %in% c(4L, -3L, 2L, 7L, 8L), logi_e))
expect_equal(or3s(lts < 1L, k %in% c(4L, -3L, 2L, 7L, 8L), logi_v),
bor3(lts < 1L, k %in% c(4L, -3L, 2L, 7L, 8L), logi_v))
expect_equal(or3s(ltt < 9L, x %in% c(4L, -3L, 2L, 7L, 8L), logi_x),
bor3(ltt < 9L, x %in% c(4L, -3L, 2L, 7L, 8L), logi_x))
expect_equal(or3s(ltu < 0L, , ),
bor3(ltu < 0L, , ))
expect_equal(or3s(ltv < 1L, , ),
bor3(ltv < 1L, , ))
expect_equal(or3s(ltw < 9L, , ),
bor3(ltw < 9L, , ))
expect_equal(or3s(ltx < 0L, , logi_r),
bor3(ltx < 0L, , logi_r))
expect_equal(or3s(lty < 1L, , logi_i),
bor3(lty < 1L, , logi_i))
expect_equal(or3s(ltz < 9L, , logi_d),
bor3(ltz < 9L, , logi_d))
expect_equal(or3s(lua < 0L, n %in% 1:4, ),
bor3(lua < 0L, n %in% 1:4, ))
expect_equal(or3s(lub < 1L, g %in% 1:4, ),
bor3(lub < 1L, g %in% 1:4, ))
expect_equal(or3s(luc < 9L, m %in% 1:4, ),
bor3(luc < 9L, m %in% 1:4, ))
expect_equal(or3s(lud < 0L, u %in% 1:4, logi_g),
bor3(lud < 0L, u %in% 1:4, logi_g))
expect_equal(or3s(lue < 1L, z %in% 1:4, logi_b),
bor3(lue < 1L, z %in% 1:4, logi_b))
expect_equal(or3s(luf < 9L, w %in% 1:4, logi_p),
bor3(luf < 9L, w %in% 1:4, logi_p))
expect_equal(or3s(lug < 0L, , ),
bor3(lug < 0L, , ))
expect_equal(or3s(luh < 1L, , ),
bor3(luh < 1L, , ))
expect_equal(or3s(lui < 9L, , ),
bor3(lui < 9L, , ))
expect_equal(or3s(luj < 0L, , !logi_c),
bor3(luj < 0L, , !logi_c))
expect_equal(or3s(luk < 1L, , !logi_i),
bor3(luk < 1L, , !logi_i))
expect_equal(or3s(lul < 9L, , !logi_n),
bor3(lul < 9L, , !logi_n))
expect_equal(or3s(lum < 0L, x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lum < 0L, x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lun < 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lun < 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(luo < 9L, x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(luo < 9L, x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lup < 0L, w %in% c(4L, -3L, 2L, 7L, 8L), !logi_w),
bor3(lup < 0L, w %in% c(4L, -3L, 2L, 7L, 8L), !logi_w))
expect_equal(or3s(luq < 1L, c %in% c(4L, -3L, 2L, 7L, 8L), !logi_y),
bor3(luq < 1L, c %in% c(4L, -3L, 2L, 7L, 8L), !logi_y))
expect_equal(or3s(lur < 9L, d %in% c(4L, -3L, 2L, 7L, 8L), !logi_n),
bor3(lur < 9L, d %in% c(4L, -3L, 2L, 7L, 8L), !logi_n))
expect_equal(or3s(lus < 0L, , ),
bor3(lus < 0L, , ))
expect_equal(or3s(lut < 1L, , ),
bor3(lut < 1L, , ))
expect_equal(or3s(luu < 9L, , ),
bor3(luu < 9L, , ))
expect_equal(or3s(luv < 0L, , !logi_p),
bor3(luv < 0L, , !logi_p))
expect_equal(or3s(luw < 1L, , !logi_l),
bor3(luw < 1L, , !logi_l))
expect_equal(or3s(lux < 9L, , !logi_n),
bor3(lux < 9L, , !logi_n))
expect_equal(or3s(luy < 0L, y %in% 1:4, ),
bor3(luy < 0L, y %in% 1:4, ))
expect_equal(or3s(luz < 1L, j %in% 1:4, ),
bor3(luz < 1L, j %in% 1:4, ))
expect_equal(or3s(lva < 9L, z %in% 1:4, ),
bor3(lva < 9L, z %in% 1:4, ))
expect_equal(or3s(lvb < 0L, f %in% 1:4, !logi_u),
bor3(lvb < 0L, f %in% 1:4, !logi_u))
expect_equal(or3s(lvc < 1L, p %in% 1:4, !logi_u),
bor3(lvc < 1L, p %in% 1:4, !logi_u))
expect_equal(or3s(lvd < 9L, b %in% 1:4, !logi_e),
bor3(lvd < 9L, b %in% 1:4, !logi_e))
expect_equal(or3s(lve < 0L, , ),
bor3(lve < 0L, , ))
expect_equal(or3s(lvf < 1L, , ),
bor3(lvf < 1L, , ))
expect_equal(or3s(lvg < 9L, , ),
bor3(lvg < 9L, , ))
expect_equal(or3s(lvh < 0L, , e != 0L),
bor3(lvh < 0L, , e != 0L))
expect_equal(or3s(lvi < 1L, , c != 1L),
bor3(lvi < 1L, , c != 1L))
expect_equal(or3s(lvj < 9L, , d != 9L),
bor3(lvj < 9L, , d != 9L))
expect_equal(or3s(lvk < 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lvk < 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lvl < 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lvl < 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lvm < 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lvm < 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lvn < 0L, w %in% c(4L, -3L, 2L, 7L, 8L), z != 0L),
bor3(lvn < 0L, w %in% c(4L, -3L, 2L, 7L, 8L), z != 0L))
expect_equal(or3s(lvo < 1L, f %in% c(4L, -3L, 2L, 7L, 8L), q != 1L),
bor3(lvo < 1L, f %in% c(4L, -3L, 2L, 7L, 8L), q != 1L))
expect_equal(or3s(lvp < 9L, y %in% c(4L, -3L, 2L, 7L, 8L), o != 9L),
bor3(lvp < 9L, y %in% c(4L, -3L, 2L, 7L, 8L), o != 9L))
expect_equal(or3s(lvq < 0L, , ),
bor3(lvq < 0L, , ))
expect_equal(or3s(lvr < 1L, , ),
bor3(lvr < 1L, , ))
expect_equal(or3s(lvs < 9L, , ),
bor3(lvs < 9L, , ))
expect_equal(or3s(lvt < 0L, , t != 0L),
bor3(lvt < 0L, , t != 0L))
expect_equal(or3s(lvu < 1L, , w != 1L),
bor3(lvu < 1L, , w != 1L))
expect_equal(or3s(lvv < 9L, , t != 9L),
bor3(lvv < 9L, , t != 9L))
expect_equal(or3s(lvw < 0L, f %in% 1:4, ),
bor3(lvw < 0L, f %in% 1:4, ))
expect_equal(or3s(lvx < 1L, k %in% 1:4, ),
bor3(lvx < 1L, k %in% 1:4, ))
expect_equal(or3s(lvy < 9L, u %in% 1:4, ),
bor3(lvy < 9L, u %in% 1:4, ))
expect_equal(or3s(lvz < 0L, t %in% 1:4, e != 0L),
bor3(lvz < 0L, t %in% 1:4, e != 0L))
expect_equal(or3s(lwa < 1L, m %in% 1:4, c != 1L),
bor3(lwa < 1L, m %in% 1:4, c != 1L))
expect_equal(or3s(lwb < 9L, d %in% 1:4, k != 9L),
bor3(lwb < 9L, d %in% 1:4, k != 9L))
expect_equal(or3s(lwc < 0L, , ),
bor3(lwc < 0L, , ))
expect_equal(or3s(lwd < 1L, , ),
bor3(lwd < 1L, , ))
expect_equal(or3s(lwe < 9L, , ),
bor3(lwe < 9L, , ))
expect_equal(or3s(lwf < 0L, , j %between% c(-1L, 1L)),
bor3(lwf < 0L, , j %between% c(-1L, 1L)))
expect_equal(or3s(lwg < 1L, , m %between% c(-1L, 1L)),
bor3(lwg < 1L, , m %between% c(-1L, 1L)))
expect_equal(or3s(lwh < 9L, , e %between% c(-1L, 1L)),
bor3(lwh < 9L, , e %between% c(-1L, 1L)))
expect_equal(or3s(lwi < 0L, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lwi < 0L, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lwj < 1L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lwj < 1L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lwk < 9L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lwk < 9L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lwl < 0L, r %in% c(4L, -3L, 2L, 7L, 8L), a %between% c(-1L, 1L)),
bor3(lwl < 0L, r %in% c(4L, -3L, 2L, 7L, 8L), a %between% c(-1L, 1L)))
expect_equal(or3s(lwm < 1L, a %in% c(4L, -3L, 2L, 7L, 8L), r %between% c(-1L, 1L)),
bor3(lwm < 1L, a %in% c(4L, -3L, 2L, 7L, 8L), r %between% c(-1L, 1L)))
expect_equal(or3s(lwn < 9L, t %in% c(4L, -3L, 2L, 7L, 8L), v %between% c(-1L, 1L)),
bor3(lwn < 9L, t %in% c(4L, -3L, 2L, 7L, 8L), v %between% c(-1L, 1L)))
expect_equal(or3s(lwo < 0L, , ),
bor3(lwo < 0L, , ))
expect_equal(or3s(lwp < 1L, , ),
bor3(lwp < 1L, , ))
expect_equal(or3s(lwq < 9L, , ),
bor3(lwq < 9L, , ))
expect_equal(or3s(lwr < 0L, , g %between% c(-1L, 1L)),
bor3(lwr < 0L, , g %between% c(-1L, 1L)))
expect_equal(or3s(lws < 1L, , l %between% c(-1L, 1L)),
bor3(lws < 1L, , l %between% c(-1L, 1L)))
expect_equal(or3s(lwt < 9L, , a %between% c(-1L, 1L)),
bor3(lwt < 9L, , a %between% c(-1L, 1L)))
expect_equal(or3s(lwu < 0L, i %in% 1:4, ),
bor3(lwu < 0L, i %in% 1:4, ))
expect_equal(or3s(lwv < 1L, l %in% 1:4, ),
bor3(lwv < 1L, l %in% 1:4, ))
expect_equal(or3s(lww < 9L, c %in% 1:4, ),
bor3(lww < 9L, c %in% 1:4, ))
expect_equal(or3s(lwx < 0L, d %in% 1:4, g %between% c(-1L, 1L)),
bor3(lwx < 0L, d %in% 1:4, g %between% c(-1L, 1L)))
expect_equal(or3s(lwy < 1L, r %in% 1:4, l %between% c(-1L, 1L)),
bor3(lwy < 1L, r %in% 1:4, l %between% c(-1L, 1L)))
expect_equal(or3s(lwz < 9L, j %in% 1:4, s %between% c(-1L, 1L)),
bor3(lwz < 9L, j %in% 1:4, s %between% c(-1L, 1L)))
expect_equal(or3s(lxa < 0L, , ),
bor3(lxa < 0L, , ))
expect_equal(or3s(lxb < 1L, , ),
bor3(lxb < 1L, , ))
expect_equal(or3s(lxc < 9L, , ),
bor3(lxc < 9L, , ))
expect_equal(or3s(lxd < 0L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lxd < 0L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lxe < 1L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lxe < 1L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lxf < 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lxf < 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lxg < 0L, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lxg < 0L, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lxh < 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lxh < 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lxi < 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lxi < 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lxj < 0L, s %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lxj < 0L, s %in% c(4L, -3L, 2L, 7L, 8L), g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lxk < 1L, s %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lxk < 1L, s %in% c(4L, -3L, 2L, 7L, 8L), m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lxl < 9L, r %in% c(4L, -3L, 2L, 7L, 8L), n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(lxl < 9L, r %in% c(4L, -3L, 2L, 7L, 8L), n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(lxm < 0L, , ),
bor3(lxm < 0L, , ))
expect_equal(or3s(lxn < 1L, , ),
bor3(lxn < 1L, , ))
expect_equal(or3s(lxo < 9L, , ),
bor3(lxo < 9L, , ))
expect_equal(or3s(lxp < 0L, , w %in% 1:4),
bor3(lxp < 0L, , w %in% 1:4))
expect_equal(or3s(lxq < 1L, , w %in% 1:4),
bor3(lxq < 1L, , w %in% 1:4))
expect_equal(or3s(lxr < 9L, , a %in% 1:4),
bor3(lxr < 9L, , a %in% 1:4))
expect_equal(or3s(lxs < 0L, p %in% 1:4, ),
bor3(lxs < 0L, p %in% 1:4, ))
expect_equal(or3s(lxt < 1L, o %in% 1:4, ),
bor3(lxt < 1L, o %in% 1:4, ))
expect_equal(or3s(lxu < 9L, q %in% 1:4, ),
bor3(lxu < 9L, q %in% 1:4, ))
expect_equal(or3s(lxv < 0L, e %in% 1:4, s %in% 1:4),
bor3(lxv < 0L, e %in% 1:4, s %in% 1:4))
expect_equal(or3s(lxw < 1L, s %in% 1:4, d %in% 1:4),
bor3(lxw < 1L, s %in% 1:4, d %in% 1:4))
expect_equal(or3s(lxx < 9L, a %in% 1:4, m %in% 1:4),
bor3(lxx < 9L, a %in% 1:4, m %in% 1:4))
expect_equal(or3s(lxy < 0L, , ),
bor3(lxy < 0L, , ))
expect_equal(or3s(lxz < 1L, , ),
bor3(lxz < 1L, , ))
expect_equal(or3s(lya < 9L, , ),
bor3(lya < 9L, , ))
expect_equal(or3s(lyb < 0L, , h < 0L),
bor3(lyb < 0L, , h < 0L))
expect_equal(or3s(lyc < 1L, , s < 1L),
bor3(lyc < 1L, , s < 1L))
expect_equal(or3s(lyd < 9L, , k < 9L),
bor3(lyd < 9L, , k < 9L))
expect_equal(or3s(lye < 0L, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lye < 0L, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lyf < 1L, a %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lyf < 1L, a %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lyg < 9L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(lyg < 9L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(lyh < 0L, w %in% c(4L, -3L, 2L, 7L, 8L), i < 0L),
bor3(lyh < 0L, w %in% c(4L, -3L, 2L, 7L, 8L), i < 0L))
expect_equal(or3s(lyi < 1L, o %in% c(4L, -3L, 2L, 7L, 8L), r < 1L),
bor3(lyi < 1L, o %in% c(4L, -3L, 2L, 7L, 8L), r < 1L))
expect_equal(or3s(lyj < 9L, j %in% c(4L, -3L, 2L, 7L, 8L), d < 9L),
bor3(lyj < 9L, j %in% c(4L, -3L, 2L, 7L, 8L), d < 9L))
expect_equal(or3s(lyk < 0L, , ),
bor3(lyk < 0L, , ))
expect_equal(or3s(lyl < 1L, , ),
bor3(lyl < 1L, , ))
expect_equal(or3s(lym < 9L, , ),
bor3(lym < 9L, , ))
expect_equal(or3s(lyn < 0L, , i < 0L),
bor3(lyn < 0L, , i < 0L))
expect_equal(or3s(lyo < 1L, , x < 1L),
bor3(lyo < 1L, , x < 1L))
expect_equal(or3s(lyp < 9L, , d < 9L),
bor3(lyp < 9L, , d < 9L))
expect_equal(or3s(lyq < 0L, h %in% 1:4, ),
bor3(lyq < 0L, h %in% 1:4, ))
expect_equal(or3s(lyr < 1L, y %in% 1:4, ),
bor3(lyr < 1L, y %in% 1:4, ))
expect_equal(or3s(lys < 9L, t %in% 1:4, ),
bor3(lys < 9L, t %in% 1:4, ))
expect_equal(or3s(lyt < 0L, y %in% 1:4, g < 0L),
bor3(lyt < 0L, y %in% 1:4, g < 0L))
expect_equal(or3s(lyu < 1L, h %in% 1:4, e < 1L),
bor3(lyu < 1L, h %in% 1:4, e < 1L))
expect_equal(or3s(lyv < 9L, z %in% 1:4, p < 9L),
bor3(lyv < 9L, z %in% 1:4, p < 9L))
expect_equal(or3s(lyw < 0L, , ),
bor3(lyw < 0L, , ))
expect_equal(or3s(lyx < 1L, , ),
bor3(lyx < 1L, , ))
expect_equal(or3s(lyy < 9L, , ),
bor3(lyy < 9L, , ))
expect_equal(or3s(lyz < 0L, , u <= 0L),
bor3(lyz < 0L, , u <= 0L))
expect_equal(or3s(ma < 1L, , h <= 1L),
bor3(ma < 1L, , h <= 1L))
expect_equal(or3s(mb < 9L, , y <= 9L),
bor3(mb < 9L, , y <= 9L))
expect_equal(or3s(mc < 0L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mc < 0L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(md < 1L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(md < 1L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(me < 9L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(me < 9L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mf < 0L, c %in% c(4L, -3L, 2L, 7L, 8L), u <= 0L),
bor3(mf < 0L, c %in% c(4L, -3L, 2L, 7L, 8L), u <= 0L))
expect_equal(or3s(mg < 1L, r %in% c(4L, -3L, 2L, 7L, 8L), r <= 1L),
bor3(mg < 1L, r %in% c(4L, -3L, 2L, 7L, 8L), r <= 1L))
expect_equal(or3s(mh < 9L, i %in% c(4L, -3L, 2L, 7L, 8L), m <= 9L),
bor3(mh < 9L, i %in% c(4L, -3L, 2L, 7L, 8L), m <= 9L))
expect_equal(or3s(mi < 0L, , ),
bor3(mi < 0L, , ))
expect_equal(or3s(mj < 1L, , ),
bor3(mj < 1L, , ))
expect_equal(or3s(mk < 9L, , ),
bor3(mk < 9L, , ))
expect_equal(or3s(ml < 0L, , r <= 0L),
bor3(ml < 0L, , r <= 0L))
expect_equal(or3s(mm < 1L, , u <= 1L),
bor3(mm < 1L, , u <= 1L))
expect_equal(or3s(mn < 9L, , q <= 9L),
bor3(mn < 9L, , q <= 9L))
expect_equal(or3s(mo < 0L, d %in% 1:4, ),
bor3(mo < 0L, d %in% 1:4, ))
expect_equal(or3s(mp < 1L, d %in% 1:4, ),
bor3(mp < 1L, d %in% 1:4, ))
expect_equal(or3s(mq < 9L, p %in% 1:4, ),
bor3(mq < 9L, p %in% 1:4, ))
expect_equal(or3s(mr < 0L, u %in% 1:4, j <= 0L),
bor3(mr < 0L, u %in% 1:4, j <= 0L))
expect_equal(or3s(ms < 1L, k %in% 1:4, y <= 1L),
bor3(ms < 1L, k %in% 1:4, y <= 1L))
expect_equal(or3s(mt < 9L, a %in% 1:4, n <= 9L),
bor3(mt < 9L, a %in% 1:4, n <= 9L))
expect_equal(or3s(mu < 0L, , ),
bor3(mu < 0L, , ))
expect_equal(or3s(mv < 1L, , ),
bor3(mv < 1L, , ))
expect_equal(or3s(mw < 9L, , ),
bor3(mw < 9L, , ))
expect_equal(or3s(mx < 0L, , j == 0L),
bor3(mx < 0L, , j == 0L))
expect_equal(or3s(my < 1L, , r == 1L),
bor3(my < 1L, , r == 1L))
expect_equal(or3s(mz < 9L, , g == 9L),
bor3(mz < 9L, , g == 9L))
expect_equal(or3s(maa < 0L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(maa < 0L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mab < 1L, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mab < 1L, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mac < 9L, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mac < 9L, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mad < 0L, a %in% c(4L, -3L, 2L, 7L, 8L), g == 0L),
bor3(mad < 0L, a %in% c(4L, -3L, 2L, 7L, 8L), g == 0L))
expect_equal(or3s(mae < 1L, t %in% c(4L, -3L, 2L, 7L, 8L), x == 1L),
bor3(mae < 1L, t %in% c(4L, -3L, 2L, 7L, 8L), x == 1L))
expect_equal(or3s(maf < 9L, g %in% c(4L, -3L, 2L, 7L, 8L), i == 9L),
bor3(maf < 9L, g %in% c(4L, -3L, 2L, 7L, 8L), i == 9L))
expect_equal(or3s(mag < 0L, , ),
bor3(mag < 0L, , ))
expect_equal(or3s(mah < 1L, , ),
bor3(mah < 1L, , ))
expect_equal(or3s(mai < 9L, , ),
bor3(mai < 9L, , ))
expect_equal(or3s(maj < 0L, , t == 0L),
bor3(maj < 0L, , t == 0L))
expect_equal(or3s(mak < 1L, , w == 1L),
bor3(mak < 1L, , w == 1L))
expect_equal(or3s(mal < 9L, , q == 9L),
bor3(mal < 9L, , q == 9L))
expect_equal(or3s(mam < 0L, b %in% 1:4, ),
bor3(mam < 0L, b %in% 1:4, ))
expect_equal(or3s(man < 1L, b %in% 1:4, ),
bor3(man < 1L, b %in% 1:4, ))
expect_equal(or3s(mao < 9L, r %in% 1:4, ),
bor3(mao < 9L, r %in% 1:4, ))
expect_equal(or3s(map < 0L, s %in% 1:4, b == 0L),
bor3(map < 0L, s %in% 1:4, b == 0L))
expect_equal(or3s(maq < 1L, b %in% 1:4, k == 1L),
bor3(maq < 1L, b %in% 1:4, k == 1L))
expect_equal(or3s(mar < 9L, z %in% 1:4, a == 9L),
bor3(mar < 9L, z %in% 1:4, a == 9L))
expect_equal(or3s(mas < 0L, , ),
bor3(mas < 0L, , ))
expect_equal(or3s(mat < 1L, , ),
bor3(mat < 1L, , ))
expect_equal(or3s(mau < 9L, , ),
bor3(mau < 9L, , ))
expect_equal(or3s(mav < 0L, , y > 0L),
bor3(mav < 0L, , y > 0L))
expect_equal(or3s(maw < 1L, , l > 1L),
bor3(maw < 1L, , l > 1L))
expect_equal(or3s(max < 9L, , b > 9L),
bor3(max < 9L, , b > 9L))
expect_equal(or3s(may < 0L, u %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(may < 0L, u %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(maz < 1L, a %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(maz < 1L, a %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mba < 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mba < 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mbb < 0L, x %in% c(4L, -3L, 2L, 7L, 8L), u > 0L),
bor3(mbb < 0L, x %in% c(4L, -3L, 2L, 7L, 8L), u > 0L))
expect_equal(or3s(mbc < 1L, x %in% c(4L, -3L, 2L, 7L, 8L), f > 1L),
bor3(mbc < 1L, x %in% c(4L, -3L, 2L, 7L, 8L), f > 1L))
expect_equal(or3s(mbd < 9L, o %in% c(4L, -3L, 2L, 7L, 8L), e > 9L),
bor3(mbd < 9L, o %in% c(4L, -3L, 2L, 7L, 8L), e > 9L))
expect_equal(or3s(mbe < 0L, , ),
bor3(mbe < 0L, , ))
expect_equal(or3s(mbf < 1L, , ),
bor3(mbf < 1L, , ))
expect_equal(or3s(mbg < 9L, , ),
bor3(mbg < 9L, , ))
expect_equal(or3s(mbh < 0L, , j > 0L),
bor3(mbh < 0L, , j > 0L))
expect_equal(or3s(mbi < 1L, , y > 1L),
bor3(mbi < 1L, , y > 1L))
expect_equal(or3s(mbj < 9L, , o > 9L),
bor3(mbj < 9L, , o > 9L))
expect_equal(or3s(mbk < 0L, z %in% 1:4, ),
bor3(mbk < 0L, z %in% 1:4, ))
expect_equal(or3s(mbl < 1L, j %in% 1:4, ),
bor3(mbl < 1L, j %in% 1:4, ))
expect_equal(or3s(mbm < 9L, x %in% 1:4, ),
bor3(mbm < 9L, x %in% 1:4, ))
expect_equal(or3s(mbn < 0L, e %in% 1:4, c > 0L),
bor3(mbn < 0L, e %in% 1:4, c > 0L))
expect_equal(or3s(mbo < 1L, y %in% 1:4, p > 1L),
bor3(mbo < 1L, y %in% 1:4, p > 1L))
expect_equal(or3s(mbp < 9L, p %in% 1:4, r > 9L),
bor3(mbp < 9L, p %in% 1:4, r > 9L))
expect_equal(or3s(mbq < 0L, , ),
bor3(mbq < 0L, , ))
expect_equal(or3s(mbr < 1L, , ),
bor3(mbr < 1L, , ))
expect_equal(or3s(mbs < 9L, , ),
bor3(mbs < 9L, , ))
expect_equal(or3s(mbt < 0L, , n >= 0L),
bor3(mbt < 0L, , n >= 0L))
expect_equal(or3s(mbu < 1L, , w >= 1L),
bor3(mbu < 1L, , w >= 1L))
expect_equal(or3s(mbv < 9L, , q >= 9L),
bor3(mbv < 9L, , q >= 9L))
expect_equal(or3s(mbw < 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mbw < 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mbx < 1L, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mbx < 1L, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mby < 9L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(mby < 9L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(mbz < 0L, n %in% c(4L, -3L, 2L, 7L, 8L), y >= 0L),
bor3(mbz < 0L, n %in% c(4L, -3L, 2L, 7L, 8L), y >= 0L))
expect_equal(or3s(mca < 1L, x %in% c(4L, -3L, 2L, 7L, 8L), w >= 1L),
bor3(mca < 1L, x %in% c(4L, -3L, 2L, 7L, 8L), w >= 1L))
expect_equal(or3s(mcb < 9L, g %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L),
bor3(mcb < 9L, g %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L))
expect_equal(or3s(mcc < 0L, , ),
bor3(mcc < 0L, , ))
expect_equal(or3s(mcd < 1L, , ),
bor3(mcd < 1L, , ))
expect_equal(or3s(mce < 9L, , ),
bor3(mce < 9L, , ))
expect_equal(or3s(mcf < 0L, , z >= 0L),
bor3(mcf < 0L, , z >= 0L))
expect_equal(or3s(mcg < 1L, , m >= 1L),
bor3(mcg < 1L, , m >= 1L))
expect_equal(or3s(mch < 9L, , h >= 9L),
bor3(mch < 9L, , h >= 9L))
expect_equal(or3s(mci < 0L, d %in% 1:4, ),
bor3(mci < 0L, d %in% 1:4, ))
expect_equal(or3s(mcj < 1L, u %in% 1:4, ),
bor3(mcj < 1L, u %in% 1:4, ))
expect_equal(or3s(mck < 9L, j %in% 1:4, ),
bor3(mck < 9L, j %in% 1:4, ))
expect_equal(or3s(mcl < 0L, b %in% 1:4, k >= 0L),
bor3(mcl < 0L, b %in% 1:4, k >= 0L))
expect_equal(or3s(mcm < 1L, y %in% 1:4, u >= 1L),
bor3(mcm < 1L, y %in% 1:4, u >= 1L))
expect_equal(or3s(mcn < 9L, t %in% 1:4, f >= 9L),
bor3(mcn < 9L, t %in% 1:4, f >= 9L))
expect_equal(or3s(mco < 0L, , ),
bor3(mco < 0L, , ))
expect_equal(or3s(mcp < 1L, , ),
bor3(mcp < 1L, , ))
expect_equal(or3s(mcq < 9L, , ),
bor3(mcq < 9L, , ))
expect_equal(or3s(mcr < 0L, , logi_d),
bor3(mcr < 0L, , logi_d))
expect_equal(or3s(mcs < 1L, , logi_m),
bor3(mcs < 1L, , logi_m))
expect_equal(or3s(mct < 9L, , logi_v),
bor3(mct < 9L, , logi_v))
expect_equal(or3s(mcu < 0L, r < 0L, ),
bor3(mcu < 0L, r < 0L, ))
expect_equal(or3s(mcv < 1L, b < 1L, ),
bor3(mcv < 1L, b < 1L, ))
expect_equal(or3s(mcw < 9L, b < 9L, ),
bor3(mcw < 9L, b < 9L, ))
expect_equal(or3s(mcx < 0L, r < 0L, logi_s),
bor3(mcx < 0L, r < 0L, logi_s))
expect_equal(or3s(mcy < 1L, d < 1L, logi_t),
bor3(mcy < 1L, d < 1L, logi_t))
expect_equal(or3s(mcz < 9L, i < 9L, logi_l),
bor3(mcz < 9L, i < 9L, logi_l))
expect_equal(or3s(mda < 0L, , ),
bor3(mda < 0L, , ))
expect_equal(or3s(mdb < 1L, , ),
bor3(mdb < 1L, , ))
expect_equal(or3s(mdc < 9L, , ),
bor3(mdc < 9L, , ))
expect_equal(or3s(mdd < 0L, , !logi_u),
bor3(mdd < 0L, , !logi_u))
expect_equal(or3s(mde < 1L, , !logi_z),
bor3(mde < 1L, , !logi_z))
expect_equal(or3s(mdf < 9L, , !logi_l),
bor3(mdf < 9L, , !logi_l))
expect_equal(or3s(mdg < 0L, a < 0L, ),
bor3(mdg < 0L, a < 0L, ))
expect_equal(or3s(mdh < 1L, j < 1L, ),
bor3(mdh < 1L, j < 1L, ))
expect_equal(or3s(mdi < 9L, y < 9L, ),
bor3(mdi < 9L, y < 9L, ))
expect_equal(or3s(mdj < 0L, w < 0L, !logi_d),
bor3(mdj < 0L, w < 0L, !logi_d))
expect_equal(or3s(mdk < 1L, m < 1L, !logi_s),
bor3(mdk < 1L, m < 1L, !logi_s))
expect_equal(or3s(mdl < 9L, w < 9L, !logi_v),
bor3(mdl < 9L, w < 9L, !logi_v))
expect_equal(or3s(mdm < 0L, , ),
bor3(mdm < 0L, , ))
expect_equal(or3s(mdn < 1L, , ),
bor3(mdn < 1L, , ))
expect_equal(or3s(mdo < 9L, , ),
bor3(mdo < 9L, , ))
expect_equal(or3s(mdp < 0L, , y != 0L),
bor3(mdp < 0L, , y != 0L))
expect_equal(or3s(mdq < 1L, , i != 1L),
bor3(mdq < 1L, , i != 1L))
expect_equal(or3s(mdr < 9L, , x != 9L),
bor3(mdr < 9L, , x != 9L))
expect_equal(or3s(mds < 0L, u < 0L, ),
bor3(mds < 0L, u < 0L, ))
expect_equal(or3s(mdt < 1L, j < 1L, ),
bor3(mdt < 1L, j < 1L, ))
expect_equal(or3s(mdu < 9L, v < 9L, ),
bor3(mdu < 9L, v < 9L, ))
expect_equal(or3s(mdv < 0L, z < 0L, t != 0L),
bor3(mdv < 0L, z < 0L, t != 0L))
expect_equal(or3s(mdw < 1L, g < 1L, c != 1L),
bor3(mdw < 1L, g < 1L, c != 1L))
expect_equal(or3s(mdx < 9L, u < 9L, f != 9L),
bor3(mdx < 9L, u < 9L, f != 9L))
expect_equal(or3s(mdy < 0L, , ),
bor3(mdy < 0L, , ))
expect_equal(or3s(mdz < 1L, , ),
bor3(mdz < 1L, , ))
expect_equal(or3s(mea < 9L, , ),
bor3(mea < 9L, , ))
expect_equal(or3s(meb < 0L, , j %between% c(-1L, 1L)),
bor3(meb < 0L, , j %between% c(-1L, 1L)))
expect_equal(or3s(mec < 1L, , o %between% c(-1L, 1L)),
bor3(mec < 1L, , o %between% c(-1L, 1L)))
expect_equal(or3s(med < 9L, , i %between% c(-1L, 1L)),
bor3(med < 9L, , i %between% c(-1L, 1L)))
expect_equal(or3s(mee < 0L, f < 0L, ),
bor3(mee < 0L, f < 0L, ))
expect_equal(or3s(mef < 1L, o < 1L, ),
bor3(mef < 1L, o < 1L, ))
expect_equal(or3s(meg < 9L, b < 9L, ),
bor3(meg < 9L, b < 9L, ))
expect_equal(or3s(meh < 0L, q < 0L, w %between% c(-1L, 1L)),
bor3(meh < 0L, q < 0L, w %between% c(-1L, 1L)))
expect_equal(or3s(mei < 1L, v < 1L, k %between% c(-1L, 1L)),
bor3(mei < 1L, v < 1L, k %between% c(-1L, 1L)))
expect_equal(or3s(mej < 9L, e < 9L, h %between% c(-1L, 1L)),
bor3(mej < 9L, e < 9L, h %between% c(-1L, 1L)))
expect_equal(or3s(mek < 0L, , ),
bor3(mek < 0L, , ))
expect_equal(or3s(mel < 1L, , ),
bor3(mel < 1L, , ))
expect_equal(or3s(mem < 9L, , ),
bor3(mem < 9L, , ))
expect_equal(or3s(men < 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(men < 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(meo < 1L, , q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(meo < 1L, , q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mep < 9L, , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mep < 9L, , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(meq < 0L, f < 0L, ),
bor3(meq < 0L, f < 0L, ))
expect_equal(or3s(mer < 1L, p < 1L, ),
bor3(mer < 1L, p < 1L, ))
expect_equal(or3s(mes < 9L, w < 9L, ),
bor3(mes < 9L, w < 9L, ))
expect_equal(or3s(met < 0L, n < 0L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(met < 0L, n < 0L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(meu < 1L, u < 1L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(meu < 1L, u < 1L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mev < 9L, q < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mev < 9L, q < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mew < 0L, , ),
bor3(mew < 0L, , ))
expect_equal(or3s(mex < 1L, , ),
bor3(mex < 1L, , ))
expect_equal(or3s(mey < 9L, , ),
bor3(mey < 9L, , ))
expect_equal(or3s(mez < 0L, , h %in% 1:4),
bor3(mez < 0L, , h %in% 1:4))
expect_equal(or3s(mfa < 1L, , d %in% 1:4),
bor3(mfa < 1L, , d %in% 1:4))
expect_equal(or3s(mfb < 9L, , c %in% 1:4),
bor3(mfb < 9L, , c %in% 1:4))
expect_equal(or3s(mfc < 0L, e < 0L, ),
bor3(mfc < 0L, e < 0L, ))
expect_equal(or3s(mfd < 1L, f < 1L, ),
bor3(mfd < 1L, f < 1L, ))
expect_equal(or3s(mfe < 9L, b < 9L, ),
bor3(mfe < 9L, b < 9L, ))
expect_equal(or3s(mff < 0L, y < 0L, r %in% 1:4),
bor3(mff < 0L, y < 0L, r %in% 1:4))
expect_equal(or3s(mfg < 1L, b < 1L, p %in% 1:4),
bor3(mfg < 1L, b < 1L, p %in% 1:4))
expect_equal(or3s(mfh < 9L, k < 9L, r %in% 1:4),
bor3(mfh < 9L, k < 9L, r %in% 1:4))
expect_equal(or3s(mfi < 0L, , ),
bor3(mfi < 0L, , ))
expect_equal(or3s(mfj < 1L, , ),
bor3(mfj < 1L, , ))
expect_equal(or3s(mfk < 9L, , ),
bor3(mfk < 9L, , ))
expect_equal(or3s(mfl < 0L, , b < 0L),
bor3(mfl < 0L, , b < 0L))
expect_equal(or3s(mfm < 1L, , h < 1L),
bor3(mfm < 1L, , h < 1L))
expect_equal(or3s(mfn < 9L, , k < 9L),
bor3(mfn < 9L, , k < 9L))
expect_equal(or3s(mfo < 0L, f < 0L, ),
bor3(mfo < 0L, f < 0L, ))
expect_equal(or3s(mfp < 1L, i < 1L, ),
bor3(mfp < 1L, i < 1L, ))
expect_equal(or3s(mfq < 9L, b < 9L, ),
bor3(mfq < 9L, b < 9L, ))
expect_equal(or3s(mfr < 0L, j < 0L, k < 0L),
bor3(mfr < 0L, j < 0L, k < 0L))
expect_equal(or3s(mfs < 1L, m < 1L, y < 1L),
bor3(mfs < 1L, m < 1L, y < 1L))
expect_equal(or3s(mft < 9L, x < 9L, i < 9L),
bor3(mft < 9L, x < 9L, i < 9L))
expect_equal(or3s(mfu < 0L, , ),
bor3(mfu < 0L, , ))
expect_equal(or3s(mfv < 1L, , ),
bor3(mfv < 1L, , ))
expect_equal(or3s(mfw < 9L, , ),
bor3(mfw < 9L, , ))
expect_equal(or3s(mfx < 0L, , x <= 0L),
bor3(mfx < 0L, , x <= 0L))
expect_equal(or3s(mfy < 1L, , o <= 1L),
bor3(mfy < 1L, , o <= 1L))
expect_equal(or3s(mfz < 9L, , w <= 9L),
bor3(mfz < 9L, , w <= 9L))
expect_equal(or3s(mga < 0L, d < 0L, ),
bor3(mga < 0L, d < 0L, ))
expect_equal(or3s(mgb < 1L, p < 1L, ),
bor3(mgb < 1L, p < 1L, ))
expect_equal(or3s(mgc < 9L, w < 9L, ),
bor3(mgc < 9L, w < 9L, ))
expect_equal(or3s(mgd < 0L, p < 0L, i <= 0L),
bor3(mgd < 0L, p < 0L, i <= 0L))
expect_equal(or3s(mge < 1L, v < 1L, j <= 1L),
bor3(mge < 1L, v < 1L, j <= 1L))
expect_equal(or3s(mgf < 9L, e < 9L, m <= 9L),
bor3(mgf < 9L, e < 9L, m <= 9L))
expect_equal(or3s(mgg < 0L, , ),
bor3(mgg < 0L, , ))
expect_equal(or3s(mgh < 1L, , ),
bor3(mgh < 1L, , ))
expect_equal(or3s(mgi < 9L, , ),
bor3(mgi < 9L, , ))
expect_equal(or3s(mgj < 0L, , x == 0L),
bor3(mgj < 0L, , x == 0L))
expect_equal(or3s(mgk < 1L, , k == 1L),
bor3(mgk < 1L, , k == 1L))
expect_equal(or3s(mgl < 9L, , f == 9L),
bor3(mgl < 9L, , f == 9L))
expect_equal(or3s(mgm < 0L, c < 0L, ),
bor3(mgm < 0L, c < 0L, ))
expect_equal(or3s(mgn < 1L, v < 1L, ),
bor3(mgn < 1L, v < 1L, ))
expect_equal(or3s(mgo < 9L, c < 9L, ),
bor3(mgo < 9L, c < 9L, ))
expect_equal(or3s(mgp < 0L, g < 0L, z == 0L),
bor3(mgp < 0L, g < 0L, z == 0L))
expect_equal(or3s(mgq < 1L, h < 1L, g == 1L),
bor3(mgq < 1L, h < 1L, g == 1L))
expect_equal(or3s(mgr < 9L, u < 9L, u == 9L),
bor3(mgr < 9L, u < 9L, u == 9L))
expect_equal(or3s(mgs < 0L, , ),
bor3(mgs < 0L, , ))
expect_equal(or3s(mgt < 1L, , ),
bor3(mgt < 1L, , ))
expect_equal(or3s(mgu < 9L, , ),
bor3(mgu < 9L, , ))
expect_equal(or3s(mgv < 0L, , z > 0L),
bor3(mgv < 0L, , z > 0L))
expect_equal(or3s(mgw < 1L, , e > 1L),
bor3(mgw < 1L, , e > 1L))
expect_equal(or3s(mgx < 9L, , a > 9L),
bor3(mgx < 9L, , a > 9L))
expect_equal(or3s(mgy < 0L, e < 0L, ),
bor3(mgy < 0L, e < 0L, ))
expect_equal(or3s(mgz < 1L, f < 1L, ),
bor3(mgz < 1L, f < 1L, ))
expect_equal(or3s(mha < 9L, r < 9L, ),
bor3(mha < 9L, r < 9L, ))
expect_equal(or3s(mhb < 0L, b < 0L, j > 0L),
bor3(mhb < 0L, b < 0L, j > 0L))
expect_equal(or3s(mhc < 1L, h < 1L, o > 1L),
bor3(mhc < 1L, h < 1L, o > 1L))
expect_equal(or3s(mhd < 9L, k < 9L, x > 9L),
bor3(mhd < 9L, k < 9L, x > 9L))
expect_equal(or3s(mhe < 0L, , ),
bor3(mhe < 0L, , ))
expect_equal(or3s(mhf < 1L, , ),
bor3(mhf < 1L, , ))
expect_equal(or3s(mhg < 9L, , ),
bor3(mhg < 9L, , ))
expect_equal(or3s(mhh < 0L, , s >= 0L),
bor3(mhh < 0L, , s >= 0L))
expect_equal(or3s(mhi < 1L, , s >= 1L),
bor3(mhi < 1L, , s >= 1L))
expect_equal(or3s(mhj < 9L, , z >= 9L),
bor3(mhj < 9L, , z >= 9L))
expect_equal(or3s(mhk < 0L, o < 0L, ),
bor3(mhk < 0L, o < 0L, ))
expect_equal(or3s(mhl < 1L, q < 1L, ),
bor3(mhl < 1L, q < 1L, ))
expect_equal(or3s(mhm < 9L, h < 9L, ),
bor3(mhm < 9L, h < 9L, ))
expect_equal(or3s(mhn < 0L, z < 0L, j >= 0L),
bor3(mhn < 0L, z < 0L, j >= 0L))
expect_equal(or3s(mho < 1L, b < 1L, b >= 1L),
bor3(mho < 1L, b < 1L, b >= 1L))
expect_equal(or3s(mhp < 9L, e < 9L, o >= 9L),
bor3(mhp < 9L, e < 9L, o >= 9L))
expect_equal(or3s(mhq < 0L, , ),
bor3(mhq < 0L, , ))
expect_equal(or3s(mhr < 1L, , ),
bor3(mhr < 1L, , ))
expect_equal(or3s(mhs < 9L, , ),
bor3(mhs < 9L, , ))
expect_equal(or3s(mht < 0L, , logi_i),
bor3(mht < 0L, , logi_i))
expect_equal(or3s(mhu < 1L, , logi_r),
bor3(mhu < 1L, , logi_r))
expect_equal(or3s(mhv < 9L, , logi_v),
bor3(mhv < 9L, , logi_v))
expect_equal(or3s(mhw < 0L, f <= 0L, ),
bor3(mhw < 0L, f <= 0L, ))
expect_equal(or3s(mhx < 1L, x <= 1L, ),
bor3(mhx < 1L, x <= 1L, ))
expect_equal(or3s(mhy < 9L, t <= 9L, ),
bor3(mhy < 9L, t <= 9L, ))
expect_equal(or3s(mhz < 0L, p <= 0L, logi_j),
bor3(mhz < 0L, p <= 0L, logi_j))
expect_equal(or3s(mia < 1L, m <= 1L, logi_y),
bor3(mia < 1L, m <= 1L, logi_y))
expect_equal(or3s(mib < 9L, f <= 9L, logi_q),
bor3(mib < 9L, f <= 9L, logi_q))
expect_equal(or3s(mic < 0L, , ),
bor3(mic < 0L, , ))
expect_equal(or3s(mid < 1L, , ),
bor3(mid < 1L, , ))
expect_equal(or3s(mie < 9L, , ),
bor3(mie < 9L, , ))
expect_equal(or3s(mif < 0L, , !logi_a),
bor3(mif < 0L, , !logi_a))
expect_equal(or3s(mig < 1L, , !logi_d),
bor3(mig < 1L, , !logi_d))
expect_equal(or3s(mih < 9L, , !logi_h),
bor3(mih < 9L, , !logi_h))
expect_equal(or3s(mii < 0L, l <= 0L, ),
bor3(mii < 0L, l <= 0L, ))
expect_equal(or3s(mij < 1L, y <= 1L, ),
bor3(mij < 1L, y <= 1L, ))
expect_equal(or3s(mik < 9L, w <= 9L, ),
bor3(mik < 9L, w <= 9L, ))
expect_equal(or3s(mil < 0L, a <= 0L, !logi_g),
bor3(mil < 0L, a <= 0L, !logi_g))
expect_equal(or3s(mim < 1L, o <= 1L, !logi_k),
bor3(mim < 1L, o <= 1L, !logi_k))
expect_equal(or3s(min < 9L, w <= 9L, !logi_w),
bor3(min < 9L, w <= 9L, !logi_w))
expect_equal(or3s(mio < 0L, , ),
bor3(mio < 0L, , ))
expect_equal(or3s(mip < 1L, , ),
bor3(mip < 1L, , ))
expect_equal(or3s(miq < 9L, , ),
bor3(miq < 9L, , ))
expect_equal(or3s(mir < 0L, , e != 0L),
bor3(mir < 0L, , e != 0L))
expect_equal(or3s(mis < 1L, , v != 1L),
bor3(mis < 1L, , v != 1L))
expect_equal(or3s(mit < 9L, , x != 9L),
bor3(mit < 9L, , x != 9L))
expect_equal(or3s(miu < 0L, g <= 0L, ),
bor3(miu < 0L, g <= 0L, ))
expect_equal(or3s(miv < 1L, j <= 1L, ),
bor3(miv < 1L, j <= 1L, ))
expect_equal(or3s(miw < 9L, o <= 9L, ),
bor3(miw < 9L, o <= 9L, ))
expect_equal(or3s(mix < 0L, s <= 0L, x != 0L),
bor3(mix < 0L, s <= 0L, x != 0L))
expect_equal(or3s(miy < 1L, q <= 1L, l != 1L),
bor3(miy < 1L, q <= 1L, l != 1L))
expect_equal(or3s(miz < 9L, i <= 9L, p != 9L),
bor3(miz < 9L, i <= 9L, p != 9L))
expect_equal(or3s(mja < 0L, , ),
bor3(mja < 0L, , ))
expect_equal(or3s(mjb < 1L, , ),
bor3(mjb < 1L, , ))
expect_equal(or3s(mjc < 9L, , ),
bor3(mjc < 9L, , ))
expect_equal(or3s(mjd < 0L, , k %between% c(-1L, 1L)),
bor3(mjd < 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(mje < 1L, , a %between% c(-1L, 1L)),
bor3(mje < 1L, , a %between% c(-1L, 1L)))
expect_equal(or3s(mjf < 9L, , q %between% c(-1L, 1L)),
bor3(mjf < 9L, , q %between% c(-1L, 1L)))
expect_equal(or3s(mjg < 0L, u <= 0L, ),
bor3(mjg < 0L, u <= 0L, ))
expect_equal(or3s(mjh < 1L, g <= 1L, ),
bor3(mjh < 1L, g <= 1L, ))
expect_equal(or3s(mji < 9L, u <= 9L, ),
bor3(mji < 9L, u <= 9L, ))
expect_equal(or3s(mjj < 0L, q <= 0L, f %between% c(-1L, 1L)),
bor3(mjj < 0L, q <= 0L, f %between% c(-1L, 1L)))
expect_equal(or3s(mjk < 1L, u <= 1L, t %between% c(-1L, 1L)),
bor3(mjk < 1L, u <= 1L, t %between% c(-1L, 1L)))
expect_equal(or3s(mjl < 9L, h <= 9L, v %between% c(-1L, 1L)),
bor3(mjl < 9L, h <= 9L, v %between% c(-1L, 1L)))
expect_equal(or3s(mjm < 0L, , ),
bor3(mjm < 0L, , ))
expect_equal(or3s(mjn < 1L, , ),
bor3(mjn < 1L, , ))
expect_equal(or3s(mjo < 9L, , ),
bor3(mjo < 9L, , ))
expect_equal(or3s(mjp < 0L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mjp < 0L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mjq < 1L, , j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mjq < 1L, , j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mjr < 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mjr < 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mjs < 0L, a <= 0L, ),
bor3(mjs < 0L, a <= 0L, ))
expect_equal(or3s(mjt < 1L, w <= 1L, ),
bor3(mjt < 1L, w <= 1L, ))
expect_equal(or3s(mju < 9L, v <= 9L, ),
bor3(mju < 9L, v <= 9L, ))
expect_equal(or3s(mjv < 0L, y <= 0L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mjv < 0L, y <= 0L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mjw < 1L, o <= 1L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mjw < 1L, o <= 1L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mjx < 9L, r <= 9L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mjx < 9L, r <= 9L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mjy < 0L, , ),
bor3(mjy < 0L, , ))
expect_equal(or3s(mjz < 1L, , ),
bor3(mjz < 1L, , ))
expect_equal(or3s(mka < 9L, , ),
bor3(mka < 9L, , ))
expect_equal(or3s(mkb < 0L, , e %in% 1:4),
bor3(mkb < 0L, , e %in% 1:4))
expect_equal(or3s(mkc < 1L, , p %in% 1:4),
bor3(mkc < 1L, , p %in% 1:4))
expect_equal(or3s(mkd < 9L, , v %in% 1:4),
bor3(mkd < 9L, , v %in% 1:4))
expect_equal(or3s(mke < 0L, g <= 0L, ),
bor3(mke < 0L, g <= 0L, ))
expect_equal(or3s(mkf < 1L, i <= 1L, ),
bor3(mkf < 1L, i <= 1L, ))
expect_equal(or3s(mkg < 9L, g <= 9L, ),
bor3(mkg < 9L, g <= 9L, ))
expect_equal(or3s(mkh < 0L, h <= 0L, m %in% 1:4),
bor3(mkh < 0L, h <= 0L, m %in% 1:4))
expect_equal(or3s(mki < 1L, y <= 1L, i %in% 1:4),
bor3(mki < 1L, y <= 1L, i %in% 1:4))
expect_equal(or3s(mkj < 9L, r <= 9L, q %in% 1:4),
bor3(mkj < 9L, r <= 9L, q %in% 1:4))
expect_equal(or3s(mkk < 0L, , ),
bor3(mkk < 0L, , ))
expect_equal(or3s(mkl < 1L, , ),
bor3(mkl < 1L, , ))
expect_equal(or3s(mkm < 9L, , ),
bor3(mkm < 9L, , ))
expect_equal(or3s(mkn < 0L, , n < 0L),
bor3(mkn < 0L, , n < 0L))
expect_equal(or3s(mko < 1L, , r < 1L),
bor3(mko < 1L, , r < 1L))
expect_equal(or3s(mkp < 9L, , q < 9L),
bor3(mkp < 9L, , q < 9L))
expect_equal(or3s(mkq < 0L, q <= 0L, ),
bor3(mkq < 0L, q <= 0L, ))
expect_equal(or3s(mkr < 1L, y <= 1L, ),
bor3(mkr < 1L, y <= 1L, ))
expect_equal(or3s(mks < 9L, k <= 9L, ),
bor3(mks < 9L, k <= 9L, ))
expect_equal(or3s(mkt < 0L, b <= 0L, c < 0L),
bor3(mkt < 0L, b <= 0L, c < 0L))
expect_equal(or3s(mku < 1L, s <= 1L, t < 1L),
bor3(mku < 1L, s <= 1L, t < 1L))
expect_equal(or3s(mkv < 9L, g <= 9L, v < 9L),
bor3(mkv < 9L, g <= 9L, v < 9L))
expect_equal(or3s(mkw < 0L, , ),
bor3(mkw < 0L, , ))
expect_equal(or3s(mkx < 1L, , ),
bor3(mkx < 1L, , ))
expect_equal(or3s(mky < 9L, , ),
bor3(mky < 9L, , ))
expect_equal(or3s(mkz < 0L, , j <= 0L),
bor3(mkz < 0L, , j <= 0L))
expect_equal(or3s(mla < 1L, , w <= 1L),
bor3(mla < 1L, , w <= 1L))
expect_equal(or3s(mlb < 9L, , l <= 9L),
bor3(mlb < 9L, , l <= 9L))
expect_equal(or3s(mlc < 0L, w <= 0L, ),
bor3(mlc < 0L, w <= 0L, ))
expect_equal(or3s(mld < 1L, j <= 1L, ),
bor3(mld < 1L, j <= 1L, ))
expect_equal(or3s(mle < 9L, m <= 9L, ),
bor3(mle < 9L, m <= 9L, ))
expect_equal(or3s(mlf < 0L, t <= 0L, w <= 0L),
bor3(mlf < 0L, t <= 0L, w <= 0L))
expect_equal(or3s(mlg < 1L, l <= 1L, z <= 1L),
bor3(mlg < 1L, l <= 1L, z <= 1L))
expect_equal(or3s(mlh < 9L, k <= 9L, x <= 9L),
bor3(mlh < 9L, k <= 9L, x <= 9L))
expect_equal(or3s(mli < 0L, , ),
bor3(mli < 0L, , ))
expect_equal(or3s(mlj < 1L, , ),
bor3(mlj < 1L, , ))
expect_equal(or3s(mlk < 9L, , ),
bor3(mlk < 9L, , ))
expect_equal(or3s(mll < 0L, , c == 0L),
bor3(mll < 0L, , c == 0L))
expect_equal(or3s(mlm < 1L, , v == 1L),
bor3(mlm < 1L, , v == 1L))
expect_equal(or3s(mln < 9L, , a == 9L),
bor3(mln < 9L, , a == 9L))
expect_equal(or3s(mlo < 0L, a <= 0L, ),
bor3(mlo < 0L, a <= 0L, ))
expect_equal(or3s(mlp < 1L, e <= 1L, ),
bor3(mlp < 1L, e <= 1L, ))
expect_equal(or3s(mlq < 9L, b <= 9L, ),
bor3(mlq < 9L, b <= 9L, ))
expect_equal(or3s(mlr < 0L, s <= 0L, k == 0L),
bor3(mlr < 0L, s <= 0L, k == 0L))
expect_equal(or3s(mls < 1L, g <= 1L, s == 1L),
bor3(mls < 1L, g <= 1L, s == 1L))
expect_equal(or3s(mlt < 9L, t <= 9L, t == 9L),
bor3(mlt < 9L, t <= 9L, t == 9L))
expect_equal(or3s(mlu < 0L, , ),
bor3(mlu < 0L, , ))
expect_equal(or3s(mlv < 1L, , ),
bor3(mlv < 1L, , ))
expect_equal(or3s(mlw < 9L, , ),
bor3(mlw < 9L, , ))
expect_equal(or3s(mlx < 0L, , n > 0L),
bor3(mlx < 0L, , n > 0L))
expect_equal(or3s(mly < 1L, , d > 1L),
bor3(mly < 1L, , d > 1L))
expect_equal(or3s(mlz < 9L, , u > 9L),
bor3(mlz < 9L, , u > 9L))
expect_equal(or3s(mma < 0L, w <= 0L, ),
bor3(mma < 0L, w <= 0L, ))
expect_equal(or3s(mmb < 1L, k <= 1L, ),
bor3(mmb < 1L, k <= 1L, ))
expect_equal(or3s(mmc < 9L, v <= 9L, ),
bor3(mmc < 9L, v <= 9L, ))
expect_equal(or3s(mmd < 0L, v <= 0L, f > 0L),
bor3(mmd < 0L, v <= 0L, f > 0L))
expect_equal(or3s(mme < 1L, p <= 1L, b > 1L),
bor3(mme < 1L, p <= 1L, b > 1L))
expect_equal(or3s(mmf < 9L, u <= 9L, h > 9L),
bor3(mmf < 9L, u <= 9L, h > 9L))
expect_equal(or3s(mmg < 0L, , ),
bor3(mmg < 0L, , ))
expect_equal(or3s(mmh < 1L, , ),
bor3(mmh < 1L, , ))
expect_equal(or3s(mmi < 9L, , ),
bor3(mmi < 9L, , ))
expect_equal(or3s(mmj < 0L, , f >= 0L),
bor3(mmj < 0L, , f >= 0L))
expect_equal(or3s(mmk < 1L, , w >= 1L),
bor3(mmk < 1L, , w >= 1L))
expect_equal(or3s(mml < 9L, , y >= 9L),
bor3(mml < 9L, , y >= 9L))
expect_equal(or3s(mmm < 0L, b <= 0L, ),
bor3(mmm < 0L, b <= 0L, ))
expect_equal(or3s(mmn < 1L, d <= 1L, ),
bor3(mmn < 1L, d <= 1L, ))
expect_equal(or3s(mmo < 9L, u <= 9L, ),
bor3(mmo < 9L, u <= 9L, ))
expect_equal(or3s(mmp < 0L, j <= 0L, f >= 0L),
bor3(mmp < 0L, j <= 0L, f >= 0L))
expect_equal(or3s(mmq < 1L, p <= 1L, j >= 1L),
bor3(mmq < 1L, p <= 1L, j >= 1L))
expect_equal(or3s(mmr < 9L, g <= 9L, t >= 9L),
bor3(mmr < 9L, g <= 9L, t >= 9L))
expect_equal(or3s(mms < 0L, , ),
bor3(mms < 0L, , ))
expect_equal(or3s(mmt < 1L, , ),
bor3(mmt < 1L, , ))
expect_equal(or3s(mmu < 9L, , ),
bor3(mmu < 9L, , ))
expect_equal(or3s(mmv < 0L, , logi_n),
bor3(mmv < 0L, , logi_n))
expect_equal(or3s(mmw < 1L, , logi_b),
bor3(mmw < 1L, , logi_b))
expect_equal(or3s(mmx < 9L, , logi_x),
bor3(mmx < 9L, , logi_x))
expect_equal(or3s(mmy < 0L, q == 0L, ),
bor3(mmy < 0L, q == 0L, ))
expect_equal(or3s(mmz < 1L, n == 1L, ),
bor3(mmz < 1L, n == 1L, ))
expect_equal(or3s(mna < 9L, l == 9L, ),
bor3(mna < 9L, l == 9L, ))
expect_equal(or3s(mnb < 0L, j == 0L, logi_n),
bor3(mnb < 0L, j == 0L, logi_n))
expect_equal(or3s(mnc < 1L, q == 1L, logi_c),
bor3(mnc < 1L, q == 1L, logi_c))
expect_equal(or3s(mnd < 9L, q == 9L, logi_d),
bor3(mnd < 9L, q == 9L, logi_d))
expect_equal(or3s(mne < 0L, , ),
bor3(mne < 0L, , ))
expect_equal(or3s(mnf < 1L, , ),
bor3(mnf < 1L, , ))
expect_equal(or3s(mng < 9L, , ),
bor3(mng < 9L, , ))
expect_equal(or3s(mnh < 0L, , !logi_u),
bor3(mnh < 0L, , !logi_u))
expect_equal(or3s(mni < 1L, , !logi_j),
bor3(mni < 1L, , !logi_j))
expect_equal(or3s(mnj < 9L, , !logi_t),
bor3(mnj < 9L, , !logi_t))
expect_equal(or3s(mnk < 0L, z == 0L, ),
bor3(mnk < 0L, z == 0L, ))
expect_equal(or3s(mnl < 1L, v == 1L, ),
bor3(mnl < 1L, v == 1L, ))
expect_equal(or3s(mnm < 9L, x == 9L, ),
bor3(mnm < 9L, x == 9L, ))
expect_equal(or3s(mnn < 0L, p == 0L, !logi_p),
bor3(mnn < 0L, p == 0L, !logi_p))
expect_equal(or3s(mno < 1L, k == 1L, !logi_w),
bor3(mno < 1L, k == 1L, !logi_w))
expect_equal(or3s(mnp < 9L, n == 9L, !logi_t),
bor3(mnp < 9L, n == 9L, !logi_t))
expect_equal(or3s(mnq < 0L, , ),
bor3(mnq < 0L, , ))
expect_equal(or3s(mnr < 1L, , ),
bor3(mnr < 1L, , ))
expect_equal(or3s(mns < 9L, , ),
bor3(mns < 9L, , ))
expect_equal(or3s(mnt < 0L, , t != 0L),
bor3(mnt < 0L, , t != 0L))
expect_equal(or3s(mnu < 1L, , o != 1L),
bor3(mnu < 1L, , o != 1L))
expect_equal(or3s(mnv < 9L, , r != 9L),
bor3(mnv < 9L, , r != 9L))
expect_equal(or3s(mnw < 0L, t == 0L, ),
bor3(mnw < 0L, t == 0L, ))
expect_equal(or3s(mnx < 1L, c == 1L, ),
bor3(mnx < 1L, c == 1L, ))
expect_equal(or3s(mny < 9L, i == 9L, ),
bor3(mny < 9L, i == 9L, ))
expect_equal(or3s(mnz < 0L, m == 0L, m != 0L),
bor3(mnz < 0L, m == 0L, m != 0L))
expect_equal(or3s(moa < 1L, s == 1L, h != 1L),
bor3(moa < 1L, s == 1L, h != 1L))
expect_equal(or3s(mob < 9L, o == 9L, r != 9L),
bor3(mob < 9L, o == 9L, r != 9L))
expect_equal(or3s(moc < 0L, , ),
bor3(moc < 0L, , ))
expect_equal(or3s(mod < 1L, , ),
bor3(mod < 1L, , ))
expect_equal(or3s(moe < 9L, , ),
bor3(moe < 9L, , ))
expect_equal(or3s(mof < 0L, , d %between% c(-1L, 1L)),
bor3(mof < 0L, , d %between% c(-1L, 1L)))
expect_equal(or3s(mog < 1L, , y %between% c(-1L, 1L)),
bor3(mog < 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(moh < 9L, , e %between% c(-1L, 1L)),
bor3(moh < 9L, , e %between% c(-1L, 1L)))
expect_equal(or3s(moi < 0L, i == 0L, ),
bor3(moi < 0L, i == 0L, ))
expect_equal(or3s(moj < 1L, h == 1L, ),
bor3(moj < 1L, h == 1L, ))
expect_equal(or3s(mok < 9L, q == 9L, ),
bor3(mok < 9L, q == 9L, ))
expect_equal(or3s(mol < 0L, f == 0L, r %between% c(-1L, 1L)),
bor3(mol < 0L, f == 0L, r %between% c(-1L, 1L)))
expect_equal(or3s(mom < 1L, l == 1L, k %between% c(-1L, 1L)),
bor3(mom < 1L, l == 1L, k %between% c(-1L, 1L)))
expect_equal(or3s(mon < 9L, l == 9L, x %between% c(-1L, 1L)),
bor3(mon < 9L, l == 9L, x %between% c(-1L, 1L)))
expect_equal(or3s(moo < 0L, , ),
bor3(moo < 0L, , ))
expect_equal(or3s(mop < 1L, , ),
bor3(mop < 1L, , ))
expect_equal(or3s(moq < 9L, , ),
bor3(moq < 9L, , ))
expect_equal(or3s(mor < 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mor < 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mos < 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mos < 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mot < 9L, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mot < 9L, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mou < 0L, b == 0L, ),
bor3(mou < 0L, b == 0L, ))
expect_equal(or3s(mov < 1L, c == 1L, ),
bor3(mov < 1L, c == 1L, ))
expect_equal(or3s(mow < 9L, c == 9L, ),
bor3(mow < 9L, c == 9L, ))
expect_equal(or3s(mox < 0L, u == 0L, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mox < 0L, u == 0L, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(moy < 1L, o == 1L, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(moy < 1L, o == 1L, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(moz < 9L, x == 9L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(moz < 9L, x == 9L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mpa < 0L, , ),
bor3(mpa < 0L, , ))
expect_equal(or3s(mpb < 1L, , ),
bor3(mpb < 1L, , ))
expect_equal(or3s(mpc < 9L, , ),
bor3(mpc < 9L, , ))
expect_equal(or3s(mpd < 0L, , y %in% 1:4),
bor3(mpd < 0L, , y %in% 1:4))
expect_equal(or3s(mpe < 1L, , n %in% 1:4),
bor3(mpe < 1L, , n %in% 1:4))
expect_equal(or3s(mpf < 9L, , f %in% 1:4),
bor3(mpf < 9L, , f %in% 1:4))
expect_equal(or3s(mpg < 0L, o == 0L, ),
bor3(mpg < 0L, o == 0L, ))
expect_equal(or3s(mph < 1L, d == 1L, ),
bor3(mph < 1L, d == 1L, ))
expect_equal(or3s(mpi < 9L, x == 9L, ),
bor3(mpi < 9L, x == 9L, ))
expect_equal(or3s(mpj < 0L, h == 0L, e %in% 1:4),
bor3(mpj < 0L, h == 0L, e %in% 1:4))
expect_equal(or3s(mpk < 1L, d == 1L, y %in% 1:4),
bor3(mpk < 1L, d == 1L, y %in% 1:4))
expect_equal(or3s(mpl < 9L, o == 9L, z %in% 1:4),
bor3(mpl < 9L, o == 9L, z %in% 1:4))
expect_equal(or3s(mpm < 0L, , ),
bor3(mpm < 0L, , ))
expect_equal(or3s(mpn < 1L, , ),
bor3(mpn < 1L, , ))
expect_equal(or3s(mpo < 9L, , ),
bor3(mpo < 9L, , ))
expect_equal(or3s(mpp < 0L, , i < 0L),
bor3(mpp < 0L, , i < 0L))
expect_equal(or3s(mpq < 1L, , r < 1L),
bor3(mpq < 1L, , r < 1L))
expect_equal(or3s(mpr < 9L, , w < 9L),
bor3(mpr < 9L, , w < 9L))
expect_equal(or3s(mps < 0L, d == 0L, ),
bor3(mps < 0L, d == 0L, ))
expect_equal(or3s(mpt < 1L, v == 1L, ),
bor3(mpt < 1L, v == 1L, ))
expect_equal(or3s(mpu < 9L, q == 9L, ),
bor3(mpu < 9L, q == 9L, ))
expect_equal(or3s(mpv < 0L, y == 0L, y < 0L),
bor3(mpv < 0L, y == 0L, y < 0L))
expect_equal(or3s(mpw < 1L, h == 1L, m < 1L),
bor3(mpw < 1L, h == 1L, m < 1L))
expect_equal(or3s(mpx < 9L, f == 9L, g < 9L),
bor3(mpx < 9L, f == 9L, g < 9L))
expect_equal(or3s(mpy < 0L, , ),
bor3(mpy < 0L, , ))
expect_equal(or3s(mpz < 1L, , ),
bor3(mpz < 1L, , ))
expect_equal(or3s(mqa < 9L, , ),
bor3(mqa < 9L, , ))
expect_equal(or3s(mqb < 0L, , d <= 0L),
bor3(mqb < 0L, , d <= 0L))
expect_equal(or3s(mqc < 1L, , b <= 1L),
bor3(mqc < 1L, , b <= 1L))
expect_equal(or3s(mqd < 9L, , w <= 9L),
bor3(mqd < 9L, , w <= 9L))
expect_equal(or3s(mqe < 0L, d == 0L, ),
bor3(mqe < 0L, d == 0L, ))
expect_equal(or3s(mqf < 1L, x == 1L, ),
bor3(mqf < 1L, x == 1L, ))
expect_equal(or3s(mqg < 9L, d == 9L, ),
bor3(mqg < 9L, d == 9L, ))
expect_equal(or3s(mqh < 0L, a == 0L, j <= 0L),
bor3(mqh < 0L, a == 0L, j <= 0L))
expect_equal(or3s(mqi < 1L, c == 1L, n <= 1L),
bor3(mqi < 1L, c == 1L, n <= 1L))
expect_equal(or3s(mqj < 9L, u == 9L, d <= 9L),
bor3(mqj < 9L, u == 9L, d <= 9L))
expect_equal(or3s(mqk < 0L, , ),
bor3(mqk < 0L, , ))
expect_equal(or3s(mql < 1L, , ),
bor3(mql < 1L, , ))
expect_equal(or3s(mqm < 9L, , ),
bor3(mqm < 9L, , ))
expect_equal(or3s(mqn < 0L, , x == 0L),
bor3(mqn < 0L, , x == 0L))
expect_equal(or3s(mqo < 1L, , o == 1L),
bor3(mqo < 1L, , o == 1L))
expect_equal(or3s(mqp < 9L, , u == 9L),
bor3(mqp < 9L, , u == 9L))
expect_equal(or3s(mqq < 0L, r == 0L, ),
bor3(mqq < 0L, r == 0L, ))
expect_equal(or3s(mqr < 1L, r == 1L, ),
bor3(mqr < 1L, r == 1L, ))
expect_equal(or3s(mqs < 9L, d == 9L, ),
bor3(mqs < 9L, d == 9L, ))
expect_equal(or3s(mqt < 0L, f == 0L, s == 0L),
bor3(mqt < 0L, f == 0L, s == 0L))
expect_equal(or3s(mqu < 1L, e == 1L, t == 1L),
bor3(mqu < 1L, e == 1L, t == 1L))
expect_equal(or3s(mqv < 9L, r == 9L, e == 9L),
bor3(mqv < 9L, r == 9L, e == 9L))
expect_equal(or3s(mqw < 0L, , ),
bor3(mqw < 0L, , ))
expect_equal(or3s(mqx < 1L, , ),
bor3(mqx < 1L, , ))
expect_equal(or3s(mqy < 9L, , ),
bor3(mqy < 9L, , ))
expect_equal(or3s(mqz < 0L, , y > 0L),
bor3(mqz < 0L, , y > 0L))
expect_equal(or3s(mra < 1L, , q > 1L),
bor3(mra < 1L, , q > 1L))
expect_equal(or3s(mrb < 9L, , j > 9L),
bor3(mrb < 9L, , j > 9L))
expect_equal(or3s(mrc < 0L, l == 0L, ),
bor3(mrc < 0L, l == 0L, ))
expect_equal(or3s(mrd < 1L, a == 1L, ),
bor3(mrd < 1L, a == 1L, ))
expect_equal(or3s(mre < 9L, h == 9L, ),
bor3(mre < 9L, h == 9L, ))
expect_equal(or3s(mrf < 0L, f == 0L, y > 0L),
bor3(mrf < 0L, f == 0L, y > 0L))
expect_equal(or3s(mrg < 1L, u == 1L, w > 1L),
bor3(mrg < 1L, u == 1L, w > 1L))
expect_equal(or3s(mrh < 9L, j == 9L, y > 9L),
bor3(mrh < 9L, j == 9L, y > 9L))
expect_equal(or3s(mri < 0L, , ),
bor3(mri < 0L, , ))
expect_equal(or3s(mrj < 1L, , ),
bor3(mrj < 1L, , ))
expect_equal(or3s(mrk < 9L, , ),
bor3(mrk < 9L, , ))
expect_equal(or3s(mrl < 0L, , i >= 0L),
bor3(mrl < 0L, , i >= 0L))
expect_equal(or3s(mrm < 1L, , l >= 1L),
bor3(mrm < 1L, , l >= 1L))
expect_equal(or3s(mrn < 9L, , y >= 9L),
bor3(mrn < 9L, , y >= 9L))
expect_equal(or3s(mro < 0L, q == 0L, ),
bor3(mro < 0L, q == 0L, ))
expect_equal(or3s(mrp < 1L, h == 1L, ),
bor3(mrp < 1L, h == 1L, ))
expect_equal(or3s(mrq < 9L, l == 9L, ),
bor3(mrq < 9L, l == 9L, ))
expect_equal(or3s(mrr < 0L, z == 0L, u >= 0L),
bor3(mrr < 0L, z == 0L, u >= 0L))
expect_equal(or3s(mrs < 1L, m == 1L, p >= 1L),
bor3(mrs < 1L, m == 1L, p >= 1L))
expect_equal(or3s(mrt < 9L, r == 9L, p >= 9L),
bor3(mrt < 9L, r == 9L, p >= 9L))
expect_equal(or3s(mru < 0L, , ),
bor3(mru < 0L, , ))
expect_equal(or3s(mrv < 1L, , ),
bor3(mrv < 1L, , ))
expect_equal(or3s(mrw < 9L, , ),
bor3(mrw < 9L, , ))
expect_equal(or3s(mrx < 0L, , logi_v),
bor3(mrx < 0L, , logi_v))
expect_equal(or3s(mry < 1L, , logi_x),
bor3(mry < 1L, , logi_x))
expect_equal(or3s(mrz < 9L, , logi_w),
bor3(mrz < 9L, , logi_w))
expect_equal(or3s(msa < 0L, s > 0L, ),
bor3(msa < 0L, s > 0L, ))
expect_equal(or3s(msb < 1L, j > 1L, ),
bor3(msb < 1L, j > 1L, ))
expect_equal(or3s(msc < 9L, c > 9L, ),
bor3(msc < 9L, c > 9L, ))
expect_equal(or3s(msd < 0L, z > 0L, logi_w),
bor3(msd < 0L, z > 0L, logi_w))
expect_equal(or3s(mse < 1L, k > 1L, logi_r),
bor3(mse < 1L, k > 1L, logi_r))
expect_equal(or3s(msf < 9L, i > 9L, logi_d),
bor3(msf < 9L, i > 9L, logi_d))
expect_equal(or3s(msg < 0L, , ),
bor3(msg < 0L, , ))
expect_equal(or3s(msh < 1L, , ),
bor3(msh < 1L, , ))
expect_equal(or3s(msi < 9L, , ),
bor3(msi < 9L, , ))
expect_equal(or3s(msj < 0L, , !logi_k),
bor3(msj < 0L, , !logi_k))
expect_equal(or3s(msk < 1L, , !logi_v),
bor3(msk < 1L, , !logi_v))
expect_equal(or3s(msl < 9L, , !logi_y),
bor3(msl < 9L, , !logi_y))
expect_equal(or3s(msm < 0L, k > 0L, ),
bor3(msm < 0L, k > 0L, ))
expect_equal(or3s(msn < 1L, h > 1L, ),
bor3(msn < 1L, h > 1L, ))
expect_equal(or3s(mso < 9L, o > 9L, ),
bor3(mso < 9L, o > 9L, ))
expect_equal(or3s(msp < 0L, l > 0L, !logi_e),
bor3(msp < 0L, l > 0L, !logi_e))
expect_equal(or3s(msq < 1L, a > 1L, !logi_n),
bor3(msq < 1L, a > 1L, !logi_n))
expect_equal(or3s(msr < 9L, p > 9L, !logi_t),
bor3(msr < 9L, p > 9L, !logi_t))
expect_equal(or3s(mss < 0L, , ),
bor3(mss < 0L, , ))
expect_equal(or3s(mst < 1L, , ),
bor3(mst < 1L, , ))
expect_equal(or3s(msu < 9L, , ),
bor3(msu < 9L, , ))
expect_equal(or3s(msv < 0L, , t != 0L),
bor3(msv < 0L, , t != 0L))
expect_equal(or3s(msw < 1L, , c != 1L),
bor3(msw < 1L, , c != 1L))
expect_equal(or3s(msx < 9L, , q != 9L),
bor3(msx < 9L, , q != 9L))
expect_equal(or3s(msy < 0L, a > 0L, ),
bor3(msy < 0L, a > 0L, ))
expect_equal(or3s(msz < 1L, p > 1L, ),
bor3(msz < 1L, p > 1L, ))
expect_equal(or3s(mta < 9L, h > 9L, ),
bor3(mta < 9L, h > 9L, ))
expect_equal(or3s(mtb < 0L, y > 0L, h != 0L),
bor3(mtb < 0L, y > 0L, h != 0L))
expect_equal(or3s(mtc < 1L, c > 1L, s != 1L),
bor3(mtc < 1L, c > 1L, s != 1L))
expect_equal(or3s(mtd < 9L, c > 9L, n != 9L),
bor3(mtd < 9L, c > 9L, n != 9L))
expect_equal(or3s(mte < 0L, , ),
bor3(mte < 0L, , ))
expect_equal(or3s(mtf < 1L, , ),
bor3(mtf < 1L, , ))
expect_equal(or3s(mtg < 9L, , ),
bor3(mtg < 9L, , ))
expect_equal(or3s(mth < 0L, , s %between% c(-1L, 1L)),
bor3(mth < 0L, , s %between% c(-1L, 1L)))
expect_equal(or3s(mti < 1L, , p %between% c(-1L, 1L)),
bor3(mti < 1L, , p %between% c(-1L, 1L)))
expect_equal(or3s(mtj < 9L, , y %between% c(-1L, 1L)),
bor3(mtj < 9L, , y %between% c(-1L, 1L)))
expect_equal(or3s(mtk < 0L, m > 0L, ),
bor3(mtk < 0L, m > 0L, ))
expect_equal(or3s(mtl < 1L, z > 1L, ),
bor3(mtl < 1L, z > 1L, ))
expect_equal(or3s(mtm < 9L, g > 9L, ),
bor3(mtm < 9L, g > 9L, ))
expect_equal(or3s(mtn < 0L, l > 0L, b %between% c(-1L, 1L)),
bor3(mtn < 0L, l > 0L, b %between% c(-1L, 1L)))
expect_equal(or3s(mto < 1L, y > 1L, i %between% c(-1L, 1L)),
bor3(mto < 1L, y > 1L, i %between% c(-1L, 1L)))
expect_equal(or3s(mtp < 9L, v > 9L, l %between% c(-1L, 1L)),
bor3(mtp < 9L, v > 9L, l %between% c(-1L, 1L)))
expect_equal(or3s(mtq < 0L, , ),
bor3(mtq < 0L, , ))
expect_equal(or3s(mtr < 1L, , ),
bor3(mtr < 1L, , ))
expect_equal(or3s(mts < 9L, , ),
bor3(mts < 9L, , ))
expect_equal(or3s(mtt < 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mtt < 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mtu < 1L, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mtu < 1L, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mtv < 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mtv < 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mtw < 0L, f > 0L, ),
bor3(mtw < 0L, f > 0L, ))
expect_equal(or3s(mtx < 1L, v > 1L, ),
bor3(mtx < 1L, v > 1L, ))
expect_equal(or3s(mty < 9L, v > 9L, ),
bor3(mty < 9L, v > 9L, ))
expect_equal(or3s(mtz < 0L, o > 0L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mtz < 0L, o > 0L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mua < 1L, s > 1L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mua < 1L, s > 1L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(mub < 9L, m > 9L, o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(mub < 9L, m > 9L, o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(muc < 0L, , ),
bor3(muc < 0L, , ))
expect_equal(or3s(mud < 1L, , ),
bor3(mud < 1L, , ))
expect_equal(or3s(mue < 9L, , ),
bor3(mue < 9L, , ))
expect_equal(or3s(muf < 0L, , a %in% 1:4),
bor3(muf < 0L, , a %in% 1:4))
expect_equal(or3s(mug < 1L, , o %in% 1:4),
bor3(mug < 1L, , o %in% 1:4))
expect_equal(or3s(muh < 9L, , g %in% 1:4),
bor3(muh < 9L, , g %in% 1:4))
expect_equal(or3s(mui < 0L, e > 0L, ),
bor3(mui < 0L, e > 0L, ))
expect_equal(or3s(muj < 1L, d > 1L, ),
bor3(muj < 1L, d > 1L, ))
expect_equal(or3s(muk < 9L, h > 9L, ),
bor3(muk < 9L, h > 9L, ))
expect_equal(or3s(mul < 0L, t > 0L, i %in% 1:4),
bor3(mul < 0L, t > 0L, i %in% 1:4))
expect_equal(or3s(mum < 1L, h > 1L, a %in% 1:4),
bor3(mum < 1L, h > 1L, a %in% 1:4))
expect_equal(or3s(mun < 9L, v > 9L, k %in% 1:4),
bor3(mun < 9L, v > 9L, k %in% 1:4))
expect_equal(or3s(muo < 0L, , ),
bor3(muo < 0L, , ))
expect_equal(or3s(mup < 1L, , ),
bor3(mup < 1L, , ))
expect_equal(or3s(muq < 9L, , ),
bor3(muq < 9L, , ))
expect_equal(or3s(mur < 0L, , y < 0L),
bor3(mur < 0L, , y < 0L))
expect_equal(or3s(mus < 1L, , k < 1L),
bor3(mus < 1L, , k < 1L))
expect_equal(or3s(mut < 9L, , h < 9L),
bor3(mut < 9L, , h < 9L))
expect_equal(or3s(muu < 0L, z > 0L, ),
bor3(muu < 0L, z > 0L, ))
expect_equal(or3s(muv < 1L, x > 1L, ),
bor3(muv < 1L, x > 1L, ))
expect_equal(or3s(muw < 9L, c > 9L, ),
bor3(muw < 9L, c > 9L, ))
expect_equal(or3s(mux < 0L, d > 0L, e < 0L),
bor3(mux < 0L, d > 0L, e < 0L))
expect_equal(or3s(muy < 1L, g > 1L, v < 1L),
bor3(muy < 1L, g > 1L, v < 1L))
expect_equal(or3s(muz < 9L, w > 9L, q < 9L),
bor3(muz < 9L, w > 9L, q < 9L))
expect_equal(or3s(mva < 0L, , ),
bor3(mva < 0L, , ))
expect_equal(or3s(mvb < 1L, , ),
bor3(mvb < 1L, , ))
expect_equal(or3s(mvc < 9L, , ),
bor3(mvc < 9L, , ))
expect_equal(or3s(mvd < 0L, , m <= 0L),
bor3(mvd < 0L, , m <= 0L))
expect_equal(or3s(mve < 1L, , n <= 1L),
bor3(mve < 1L, , n <= 1L))
expect_equal(or3s(mvf < 9L, , t <= 9L),
bor3(mvf < 9L, , t <= 9L))
expect_equal(or3s(mvg < 0L, t > 0L, ),
bor3(mvg < 0L, t > 0L, ))
expect_equal(or3s(mvh < 1L, b > 1L, ),
bor3(mvh < 1L, b > 1L, ))
expect_equal(or3s(mvi < 9L, t > 9L, ),
bor3(mvi < 9L, t > 9L, ))
expect_equal(or3s(mvj < 0L, t > 0L, e <= 0L),
bor3(mvj < 0L, t > 0L, e <= 0L))
expect_equal(or3s(mvk < 1L, s > 1L, d <= 1L),
bor3(mvk < 1L, s > 1L, d <= 1L))
expect_equal(or3s(mvl < 9L, c > 9L, b <= 9L),
bor3(mvl < 9L, c > 9L, b <= 9L))
expect_equal(or3s(mvm < 0L, , ),
bor3(mvm < 0L, , ))
expect_equal(or3s(mvn < 1L, , ),
bor3(mvn < 1L, , ))
expect_equal(or3s(mvo < 9L, , ),
bor3(mvo < 9L, , ))
expect_equal(or3s(mvp < 0L, , s == 0L),
bor3(mvp < 0L, , s == 0L))
expect_equal(or3s(mvq < 1L, , o == 1L),
bor3(mvq < 1L, , o == 1L))
expect_equal(or3s(mvr < 9L, , m == 9L),
bor3(mvr < 9L, , m == 9L))
expect_equal(or3s(mvs < 0L, t > 0L, ),
bor3(mvs < 0L, t > 0L, ))
expect_equal(or3s(mvt < 1L, a > 1L, ),
bor3(mvt < 1L, a > 1L, ))
expect_equal(or3s(mvu < 9L, j > 9L, ),
bor3(mvu < 9L, j > 9L, ))
expect_equal(or3s(mvv < 0L, p > 0L, y == 0L),
bor3(mvv < 0L, p > 0L, y == 0L))
expect_equal(or3s(mvw < 1L, b > 1L, f == 1L),
bor3(mvw < 1L, b > 1L, f == 1L))
expect_equal(or3s(mvx < 9L, k > 9L, r == 9L),
bor3(mvx < 9L, k > 9L, r == 9L))
expect_equal(or3s(mvy < 0L, , ),
bor3(mvy < 0L, , ))
expect_equal(or3s(mvz < 1L, , ),
bor3(mvz < 1L, , ))
expect_equal(or3s(mwa < 9L, , ),
bor3(mwa < 9L, , ))
expect_equal(or3s(mwb < 0L, , k > 0L),
bor3(mwb < 0L, , k > 0L))
expect_equal(or3s(mwc < 1L, , v > 1L),
bor3(mwc < 1L, , v > 1L))
expect_equal(or3s(mwd < 9L, , v > 9L),
bor3(mwd < 9L, , v > 9L))
expect_equal(or3s(mwe < 0L, r > 0L, ),
bor3(mwe < 0L, r > 0L, ))
expect_equal(or3s(mwf < 1L, n > 1L, ),
bor3(mwf < 1L, n > 1L, ))
expect_equal(or3s(mwg < 9L, l > 9L, ),
bor3(mwg < 9L, l > 9L, ))
expect_equal(or3s(mwh < 0L, f > 0L, k > 0L),
bor3(mwh < 0L, f > 0L, k > 0L))
expect_equal(or3s(mwi < 1L, w > 1L, g > 1L),
bor3(mwi < 1L, w > 1L, g > 1L))
expect_equal(or3s(mwj < 9L, j > 9L, r > 9L),
bor3(mwj < 9L, j > 9L, r > 9L))
expect_equal(or3s(mwk < 0L, , ),
bor3(mwk < 0L, , ))
expect_equal(or3s(mwl < 1L, , ),
bor3(mwl < 1L, , ))
expect_equal(or3s(mwm < 9L, , ),
bor3(mwm < 9L, , ))
expect_equal(or3s(mwn < 0L, , p >= 0L),
bor3(mwn < 0L, , p >= 0L))
expect_equal(or3s(mwo < 1L, , z >= 1L),
bor3(mwo < 1L, , z >= 1L))
expect_equal(or3s(mwp < 9L, , u >= 9L),
bor3(mwp < 9L, , u >= 9L))
expect_equal(or3s(mwq < 0L, u > 0L, ),
bor3(mwq < 0L, u > 0L, ))
expect_equal(or3s(mwr < 1L, u > 1L, ),
bor3(mwr < 1L, u > 1L, ))
expect_equal(or3s(mws < 9L, e > 9L, ),
bor3(mws < 9L, e > 9L, ))
expect_equal(or3s(mwt < 0L, b > 0L, e >= 0L),
bor3(mwt < 0L, b > 0L, e >= 0L))
expect_equal(or3s(mwu < 1L, x > 1L, s >= 1L),
bor3(mwu < 1L, x > 1L, s >= 1L))
expect_equal(or3s(mwv < 9L, h > 9L, r >= 9L),
bor3(mwv < 9L, h > 9L, r >= 9L))
expect_equal(or3s(mww < 0L, , ),
bor3(mww < 0L, , ))
expect_equal(or3s(mwx < 1L, , ),
bor3(mwx < 1L, , ))
expect_equal(or3s(mwy < 9L, , ),
bor3(mwy < 9L, , ))
expect_equal(or3s(mwz < 0L, , logi_m),
bor3(mwz < 0L, , logi_m))
expect_equal(or3s(mxa < 1L, , logi_r),
bor3(mxa < 1L, , logi_r))
expect_equal(or3s(mxb < 9L, , logi_k),
bor3(mxb < 9L, , logi_k))
expect_equal(or3s(mxc < 0L, b >= 0L, ),
bor3(mxc < 0L, b >= 0L, ))
expect_equal(or3s(mxd < 1L, s >= 1L, ),
bor3(mxd < 1L, s >= 1L, ))
expect_equal(or3s(mxe < 9L, s >= 9L, ),
bor3(mxe < 9L, s >= 9L, ))
expect_equal(or3s(mxf < 0L, l >= 0L, logi_k),
bor3(mxf < 0L, l >= 0L, logi_k))
expect_equal(or3s(mxg < 1L, d >= 1L, logi_c),
bor3(mxg < 1L, d >= 1L, logi_c))
expect_equal(or3s(mxh < 9L, c >= 9L, logi_v),
bor3(mxh < 9L, c >= 9L, logi_v))
expect_equal(or3s(mxi < 0L, , ),
bor3(mxi < 0L, , ))
expect_equal(or3s(mxj < 1L, , ),
bor3(mxj < 1L, , ))
expect_equal(or3s(mxk < 9L, , ),
bor3(mxk < 9L, , ))
expect_equal(or3s(mxl < 0L, , !logi_v),
bor3(mxl < 0L, , !logi_v))
expect_equal(or3s(mxm < 1L, , !logi_g),
bor3(mxm < 1L, , !logi_g))
expect_equal(or3s(mxn < 9L, , !logi_u),
bor3(mxn < 9L, , !logi_u))
expect_equal(or3s(mxo < 0L, l >= 0L, ),
bor3(mxo < 0L, l >= 0L, ))
expect_equal(or3s(mxp < 1L, l >= 1L, ),
bor3(mxp < 1L, l >= 1L, ))
expect_equal(or3s(mxq < 9L, v >= 9L, ),
bor3(mxq < 9L, v >= 9L, ))
expect_equal(or3s(mxr < 0L, r >= 0L, !logi_m),
bor3(mxr < 0L, r >= 0L, !logi_m))
expect_equal(or3s(mxs < 1L, z >= 1L, !logi_n),
bor3(mxs < 1L, z >= 1L, !logi_n))
expect_equal(or3s(mxt < 9L, p >= 9L, !logi_a),
bor3(mxt < 9L, p >= 9L, !logi_a))
expect_equal(or3s(mxu < 0L, , ),
bor3(mxu < 0L, , ))
expect_equal(or3s(mxv < 1L, , ),
bor3(mxv < 1L, , ))
expect_equal(or3s(mxw < 9L, , ),
bor3(mxw < 9L, , ))
expect_equal(or3s(mxx < 0L, , r != 0L),
bor3(mxx < 0L, , r != 0L))
expect_equal(or3s(mxy < 1L, , i != 1L),
bor3(mxy < 1L, , i != 1L))
expect_equal(or3s(mxz < 9L, , r != 9L),
bor3(mxz < 9L, , r != 9L))
expect_equal(or3s(mya < 0L, q >= 0L, ),
bor3(mya < 0L, q >= 0L, ))
expect_equal(or3s(myb < 1L, x >= 1L, ),
bor3(myb < 1L, x >= 1L, ))
expect_equal(or3s(myc < 9L, p >= 9L, ),
bor3(myc < 9L, p >= 9L, ))
expect_equal(or3s(myd < 0L, p >= 0L, l != 0L),
bor3(myd < 0L, p >= 0L, l != 0L))
expect_equal(or3s(mye < 1L, j >= 1L, c != 1L),
bor3(mye < 1L, j >= 1L, c != 1L))
expect_equal(or3s(myf < 9L, f >= 9L, h != 9L),
bor3(myf < 9L, f >= 9L, h != 9L))
expect_equal(or3s(myg < 0L, , ),
bor3(myg < 0L, , ))
expect_equal(or3s(myh < 1L, , ),
bor3(myh < 1L, , ))
expect_equal(or3s(myi < 9L, , ),
bor3(myi < 9L, , ))
expect_equal(or3s(myj < 0L, , a %between% c(-1L, 1L)),
bor3(myj < 0L, , a %between% c(-1L, 1L)))
expect_equal(or3s(myk < 1L, , y %between% c(-1L, 1L)),
bor3(myk < 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(myl < 9L, , r %between% c(-1L, 1L)),
bor3(myl < 9L, , r %between% c(-1L, 1L)))
expect_equal(or3s(mym < 0L, f >= 0L, ),
bor3(mym < 0L, f >= 0L, ))
expect_equal(or3s(myn < 1L, y >= 1L, ),
bor3(myn < 1L, y >= 1L, ))
expect_equal(or3s(myo < 9L, i >= 9L, ),
bor3(myo < 9L, i >= 9L, ))
expect_equal(or3s(myp < 0L, x >= 0L, m %between% c(-1L, 1L)),
bor3(myp < 0L, x >= 0L, m %between% c(-1L, 1L)))
expect_equal(or3s(myq < 1L, h >= 1L, g %between% c(-1L, 1L)),
bor3(myq < 1L, h >= 1L, g %between% c(-1L, 1L)))
expect_equal(or3s(myr < 9L, c >= 9L, q %between% c(-1L, 1L)),
bor3(myr < 9L, c >= 9L, q %between% c(-1L, 1L)))
expect_equal(or3s(mys < 0L, , ),
bor3(mys < 0L, , ))
expect_equal(or3s(myt < 1L, , ),
bor3(myt < 1L, , ))
expect_equal(or3s(myu < 9L, , ),
bor3(myu < 9L, , ))
expect_equal(or3s(myv < 0L, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(myv < 0L, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(myw < 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(myw < 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(myx < 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(myx < 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(myy < 0L, j >= 0L, ),
bor3(myy < 0L, j >= 0L, ))
expect_equal(or3s(myz < 1L, i >= 1L, ),
bor3(myz < 1L, i >= 1L, ))
expect_equal(or3s(na < 9L, u >= 9L, ),
bor3(na < 9L, u >= 9L, ))
expect_equal(or3s(nb < 0L, g >= 0L, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nb < 0L, g >= 0L, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nc < 1L, c >= 1L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nc < 1L, c >= 1L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nd < 9L, l >= 9L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nd < 9L, l >= 9L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ne < 0L, , ),
bor3(ne < 0L, , ))
expect_equal(or3s(nf < 1L, , ),
bor3(nf < 1L, , ))
expect_equal(or3s(ng < 9L, , ),
bor3(ng < 9L, , ))
expect_equal(or3s(nh < 0L, , q %in% 1:4),
bor3(nh < 0L, , q %in% 1:4))
expect_equal(or3s(ni < 1L, , g %in% 1:4),
bor3(ni < 1L, , g %in% 1:4))
expect_equal(or3s(nj < 9L, , l %in% 1:4),
bor3(nj < 9L, , l %in% 1:4))
expect_equal(or3s(nk < 0L, g >= 0L, ),
bor3(nk < 0L, g >= 0L, ))
expect_equal(or3s(nl < 1L, u >= 1L, ),
bor3(nl < 1L, u >= 1L, ))
expect_equal(or3s(nm < 9L, z >= 9L, ),
bor3(nm < 9L, z >= 9L, ))
expect_equal(or3s(nn < 0L, z >= 0L, g %in% 1:4),
bor3(nn < 0L, z >= 0L, g %in% 1:4))
expect_equal(or3s(no < 1L, y >= 1L, x %in% 1:4),
bor3(no < 1L, y >= 1L, x %in% 1:4))
expect_equal(or3s(np < 9L, l >= 9L, a %in% 1:4),
bor3(np < 9L, l >= 9L, a %in% 1:4))
expect_equal(or3s(nq < 0L, , ),
bor3(nq < 0L, , ))
expect_equal(or3s(nr < 1L, , ),
bor3(nr < 1L, , ))
expect_equal(or3s(ns < 9L, , ),
bor3(ns < 9L, , ))
expect_equal(or3s(nt < 0L, , r < 0L),
bor3(nt < 0L, , r < 0L))
expect_equal(or3s(nu < 1L, , g < 1L),
bor3(nu < 1L, , g < 1L))
expect_equal(or3s(nv < 9L, , d < 9L),
bor3(nv < 9L, , d < 9L))
expect_equal(or3s(nw < 0L, c >= 0L, ),
bor3(nw < 0L, c >= 0L, ))
expect_equal(or3s(nx < 1L, f >= 1L, ),
bor3(nx < 1L, f >= 1L, ))
expect_equal(or3s(ny < 9L, c >= 9L, ),
bor3(ny < 9L, c >= 9L, ))
expect_equal(or3s(nz < 0L, g >= 0L, e < 0L),
bor3(nz < 0L, g >= 0L, e < 0L))
expect_equal(or3s(naa < 1L, m >= 1L, t < 1L),
bor3(naa < 1L, m >= 1L, t < 1L))
expect_equal(or3s(nab < 9L, d >= 9L, l < 9L),
bor3(nab < 9L, d >= 9L, l < 9L))
expect_equal(or3s(nac < 0L, , ),
bor3(nac < 0L, , ))
expect_equal(or3s(nad < 1L, , ),
bor3(nad < 1L, , ))
expect_equal(or3s(nae < 9L, , ),
bor3(nae < 9L, , ))
expect_equal(or3s(naf < 0L, , c <= 0L),
bor3(naf < 0L, , c <= 0L))
expect_equal(or3s(nag < 1L, , x <= 1L),
bor3(nag < 1L, , x <= 1L))
expect_equal(or3s(nah < 9L, , h <= 9L),
bor3(nah < 9L, , h <= 9L))
expect_equal(or3s(nai < 0L, z >= 0L, ),
bor3(nai < 0L, z >= 0L, ))
expect_equal(or3s(naj < 1L, c >= 1L, ),
bor3(naj < 1L, c >= 1L, ))
expect_equal(or3s(nak < 9L, m >= 9L, ),
bor3(nak < 9L, m >= 9L, ))
expect_equal(or3s(nal < 0L, a >= 0L, k <= 0L),
bor3(nal < 0L, a >= 0L, k <= 0L))
expect_equal(or3s(nam < 1L, m >= 1L, b <= 1L),
bor3(nam < 1L, m >= 1L, b <= 1L))
expect_equal(or3s(nan < 9L, u >= 9L, m <= 9L),
bor3(nan < 9L, u >= 9L, m <= 9L))
expect_equal(or3s(nao < 0L, , ),
bor3(nao < 0L, , ))
expect_equal(or3s(nap < 1L, , ),
bor3(nap < 1L, , ))
expect_equal(or3s(naq < 9L, , ),
bor3(naq < 9L, , ))
expect_equal(or3s(nar < 0L, , g == 0L),
bor3(nar < 0L, , g == 0L))
expect_equal(or3s(nas < 1L, , n == 1L),
bor3(nas < 1L, , n == 1L))
expect_equal(or3s(nat < 9L, , c == 9L),
bor3(nat < 9L, , c == 9L))
expect_equal(or3s(nau < 0L, x >= 0L, ),
bor3(nau < 0L, x >= 0L, ))
expect_equal(or3s(nav < 1L, r >= 1L, ),
bor3(nav < 1L, r >= 1L, ))
expect_equal(or3s(naw < 9L, f >= 9L, ),
bor3(naw < 9L, f >= 9L, ))
expect_equal(or3s(nax < 0L, j >= 0L, f == 0L),
bor3(nax < 0L, j >= 0L, f == 0L))
expect_equal(or3s(nay < 1L, z >= 1L, v == 1L),
bor3(nay < 1L, z >= 1L, v == 1L))
expect_equal(or3s(naz < 9L, v >= 9L, y == 9L),
bor3(naz < 9L, v >= 9L, y == 9L))
expect_equal(or3s(nba < 0L, , ),
bor3(nba < 0L, , ))
expect_equal(or3s(nbb < 1L, , ),
bor3(nbb < 1L, , ))
expect_equal(or3s(nbc < 9L, , ),
bor3(nbc < 9L, , ))
expect_equal(or3s(nbd < 0L, , i > 0L),
bor3(nbd < 0L, , i > 0L))
expect_equal(or3s(nbe < 1L, , q > 1L),
bor3(nbe < 1L, , q > 1L))
expect_equal(or3s(nbf < 9L, , j > 9L),
bor3(nbf < 9L, , j > 9L))
expect_equal(or3s(nbg < 0L, g >= 0L, ),
bor3(nbg < 0L, g >= 0L, ))
expect_equal(or3s(nbh < 1L, o >= 1L, ),
bor3(nbh < 1L, o >= 1L, ))
expect_equal(or3s(nbi < 9L, t >= 9L, ),
bor3(nbi < 9L, t >= 9L, ))
expect_equal(or3s(nbj < 0L, j >= 0L, a > 0L),
bor3(nbj < 0L, j >= 0L, a > 0L))
expect_equal(or3s(nbk < 1L, y >= 1L, o > 1L),
bor3(nbk < 1L, y >= 1L, o > 1L))
expect_equal(or3s(nbl < 9L, f >= 9L, w > 9L),
bor3(nbl < 9L, f >= 9L, w > 9L))
expect_equal(or3s(nbm < 0L, , ),
bor3(nbm < 0L, , ))
expect_equal(or3s(nbn < 1L, , ),
bor3(nbn < 1L, , ))
expect_equal(or3s(nbo < 9L, , ),
bor3(nbo < 9L, , ))
expect_equal(or3s(nbp < 0L, , u >= 0L),
bor3(nbp < 0L, , u >= 0L))
expect_equal(or3s(nbq < 1L, , k >= 1L),
bor3(nbq < 1L, , k >= 1L))
expect_equal(or3s(nbr < 9L, , y >= 9L),
bor3(nbr < 9L, , y >= 9L))
expect_equal(or3s(nbs < 0L, u >= 0L, ),
bor3(nbs < 0L, u >= 0L, ))
expect_equal(or3s(nbt < 1L, y >= 1L, ),
bor3(nbt < 1L, y >= 1L, ))
expect_equal(or3s(nbu < 9L, l >= 9L, ),
bor3(nbu < 9L, l >= 9L, ))
expect_equal(or3s(nbv < 0L, g >= 0L, k >= 0L),
bor3(nbv < 0L, g >= 0L, k >= 0L))
expect_equal(or3s(nbw < 1L, r >= 1L, k >= 1L),
bor3(nbw < 1L, r >= 1L, k >= 1L))
expect_equal(or3s(nbx < 9L, c >= 9L, y >= 9L),
bor3(nbx < 9L, c >= 9L, y >= 9L))
expect_equal(or3s(nby <= 0L, , ),
bor3(nby <= 0L, , ))
expect_equal(or3s(nbz <= 1L, , ),
bor3(nbz <= 1L, , ))
expect_equal(or3s(nca <= 9L, , ),
bor3(nca <= 9L, , ))
expect_equal(or3s(ncb <= 0L, , logi_e),
bor3(ncb <= 0L, , logi_e))
expect_equal(or3s(ncc <= 1L, , logi_r),
bor3(ncc <= 1L, , logi_r))
expect_equal(or3s(ncd <= 9L, , logi_e),
bor3(ncd <= 9L, , logi_e))
expect_equal(or3s(nce <= 0L, logi_i, ),
bor3(nce <= 0L, logi_i, ))
expect_equal(or3s(ncf <= 1L, logi_u, ),
bor3(ncf <= 1L, logi_u, ))
expect_equal(or3s(ncg <= 9L, logi_p, ),
bor3(ncg <= 9L, logi_p, ))
expect_equal(or3s(nch <= 0L, logi_x, logi_c),
bor3(nch <= 0L, logi_x, logi_c))
expect_equal(or3s(nci <= 1L, logi_r, logi_w),
bor3(nci <= 1L, logi_r, logi_w))
expect_equal(or3s(ncj <= 9L, logi_n, logi_z),
bor3(ncj <= 9L, logi_n, logi_z))
expect_equal(or3s(nck <= 0L, , ),
bor3(nck <= 0L, , ))
expect_equal(or3s(ncl <= 1L, , ),
bor3(ncl <= 1L, , ))
expect_equal(or3s(ncm <= 9L, , ),
bor3(ncm <= 9L, , ))
expect_equal(or3s(ncn <= 0L, , !logi_e),
bor3(ncn <= 0L, , !logi_e))
expect_equal(or3s(nco <= 1L, , !logi_u),
bor3(nco <= 1L, , !logi_u))
expect_equal(or3s(ncp <= 9L, , !logi_q),
bor3(ncp <= 9L, , !logi_q))
expect_equal(or3s(ncq <= 0L, logi_w, ),
bor3(ncq <= 0L, logi_w, ))
expect_equal(or3s(ncr <= 1L, logi_d, ),
bor3(ncr <= 1L, logi_d, ))
expect_equal(or3s(ncs <= 9L, logi_v, ),
bor3(ncs <= 9L, logi_v, ))
expect_equal(or3s(nct <= 0L, logi_k, !logi_j),
bor3(nct <= 0L, logi_k, !logi_j))
expect_equal(or3s(ncu <= 1L, logi_j, !logi_k),
bor3(ncu <= 1L, logi_j, !logi_k))
expect_equal(or3s(ncv <= 9L, logi_z, !logi_q),
bor3(ncv <= 9L, logi_z, !logi_q))
expect_equal(or3s(ncw <= 0L, , ),
bor3(ncw <= 0L, , ))
expect_equal(or3s(ncx <= 1L, , ),
bor3(ncx <= 1L, , ))
expect_equal(or3s(ncy <= 9L, , ),
bor3(ncy <= 9L, , ))
expect_equal(or3s(ncz <= 0L, , c != 0L),
bor3(ncz <= 0L, , c != 0L))
expect_equal(or3s(nda <= 1L, , d != 1L),
bor3(nda <= 1L, , d != 1L))
expect_equal(or3s(ndb <= 9L, , o != 9L),
bor3(ndb <= 9L, , o != 9L))
expect_equal(or3s(ndc <= 0L, logi_a, ),
bor3(ndc <= 0L, logi_a, ))
expect_equal(or3s(ndd <= 1L, logi_r, ),
bor3(ndd <= 1L, logi_r, ))
expect_equal(or3s(nde <= 9L, logi_o, ),
bor3(nde <= 9L, logi_o, ))
expect_equal(or3s(ndf <= 0L, logi_n, f != 0L),
bor3(ndf <= 0L, logi_n, f != 0L))
expect_equal(or3s(ndg <= 1L, logi_e, e != 1L),
bor3(ndg <= 1L, logi_e, e != 1L))
expect_equal(or3s(ndh <= 9L, logi_z, k != 9L),
bor3(ndh <= 9L, logi_z, k != 9L))
expect_equal(or3s(ndi <= 0L, , ),
bor3(ndi <= 0L, , ))
expect_equal(or3s(ndj <= 1L, , ),
bor3(ndj <= 1L, , ))
expect_equal(or3s(ndk <= 9L, , ),
bor3(ndk <= 9L, , ))
expect_equal(or3s(ndl <= 0L, , u %between% c(-1L, 1L)),
bor3(ndl <= 0L, , u %between% c(-1L, 1L)))
expect_equal(or3s(ndm <= 1L, , t %between% c(-1L, 1L)),
bor3(ndm <= 1L, , t %between% c(-1L, 1L)))
expect_equal(or3s(ndn <= 9L, , l %between% c(-1L, 1L)),
bor3(ndn <= 9L, , l %between% c(-1L, 1L)))
expect_equal(or3s(ndo <= 0L, logi_s, ),
bor3(ndo <= 0L, logi_s, ))
expect_equal(or3s(ndp <= 1L, logi_d, ),
bor3(ndp <= 1L, logi_d, ))
expect_equal(or3s(ndq <= 9L, logi_e, ),
bor3(ndq <= 9L, logi_e, ))
expect_equal(or3s(ndr <= 0L, logi_h, z %between% c(-1L, 1L)),
bor3(ndr <= 0L, logi_h, z %between% c(-1L, 1L)))
expect_equal(or3s(nds <= 1L, logi_w, w %between% c(-1L, 1L)),
bor3(nds <= 1L, logi_w, w %between% c(-1L, 1L)))
expect_equal(or3s(ndt <= 9L, logi_n, y %between% c(-1L, 1L)),
bor3(ndt <= 9L, logi_n, y %between% c(-1L, 1L)))
expect_equal(or3s(ndu <= 0L, , ),
bor3(ndu <= 0L, , ))
expect_equal(or3s(ndv <= 1L, , ),
bor3(ndv <= 1L, , ))
expect_equal(or3s(ndw <= 9L, , ),
bor3(ndw <= 9L, , ))
expect_equal(or3s(ndx <= 0L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ndx <= 0L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ndy <= 1L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ndy <= 1L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ndz <= 9L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ndz <= 9L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nea <= 0L, logi_t, ),
bor3(nea <= 0L, logi_t, ))
expect_equal(or3s(neb <= 1L, logi_m, ),
bor3(neb <= 1L, logi_m, ))
expect_equal(or3s(nec <= 9L, logi_r, ),
bor3(nec <= 9L, logi_r, ))
expect_equal(or3s(ned <= 0L, logi_f, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ned <= 0L, logi_f, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nee <= 1L, logi_l, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nee <= 1L, logi_l, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nef <= 9L, logi_l, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nef <= 9L, logi_l, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(neg <= 0L, , ),
bor3(neg <= 0L, , ))
expect_equal(or3s(neh <= 1L, , ),
bor3(neh <= 1L, , ))
expect_equal(or3s(nei <= 9L, , ),
bor3(nei <= 9L, , ))
expect_equal(or3s(nej <= 0L, , r %in% 1:4),
bor3(nej <= 0L, , r %in% 1:4))
expect_equal(or3s(nek <= 1L, , o %in% 1:4),
bor3(nek <= 1L, , o %in% 1:4))
expect_equal(or3s(nel <= 9L, , c %in% 1:4),
bor3(nel <= 9L, , c %in% 1:4))
expect_equal(or3s(nem <= 0L, logi_t, ),
bor3(nem <= 0L, logi_t, ))
expect_equal(or3s(nen <= 1L, logi_a, ),
bor3(nen <= 1L, logi_a, ))
expect_equal(or3s(neo <= 9L, logi_q, ),
bor3(neo <= 9L, logi_q, ))
expect_equal(or3s(nep <= 0L, logi_h, q %in% 1:4),
bor3(nep <= 0L, logi_h, q %in% 1:4))
expect_equal(or3s(neq <= 1L, logi_b, e %in% 1:4),
bor3(neq <= 1L, logi_b, e %in% 1:4))
expect_equal(or3s(ner <= 9L, logi_w, o %in% 1:4),
bor3(ner <= 9L, logi_w, o %in% 1:4))
expect_equal(or3s(nes <= 0L, , ),
bor3(nes <= 0L, , ))
expect_equal(or3s(net <= 1L, , ),
bor3(net <= 1L, , ))
expect_equal(or3s(neu <= 9L, , ),
bor3(neu <= 9L, , ))
expect_equal(or3s(nev <= 0L, , y < 0L),
bor3(nev <= 0L, , y < 0L))
expect_equal(or3s(new <= 1L, , m < 1L),
bor3(new <= 1L, , m < 1L))
expect_equal(or3s(nex <= 9L, , v < 9L),
bor3(nex <= 9L, , v < 9L))
expect_equal(or3s(ney <= 0L, logi_c, ),
bor3(ney <= 0L, logi_c, ))
expect_equal(or3s(nez <= 1L, logi_g, ),
bor3(nez <= 1L, logi_g, ))
expect_equal(or3s(nfa <= 9L, logi_e, ),
bor3(nfa <= 9L, logi_e, ))
expect_equal(or3s(nfb <= 0L, logi_y, k < 0L),
bor3(nfb <= 0L, logi_y, k < 0L))
expect_equal(or3s(nfc <= 1L, logi_o, f < 1L),
bor3(nfc <= 1L, logi_o, f < 1L))
expect_equal(or3s(nfd <= 9L, logi_b, j < 9L),
bor3(nfd <= 9L, logi_b, j < 9L))
expect_equal(or3s(nfe <= 0L, , ),
bor3(nfe <= 0L, , ))
expect_equal(or3s(nff <= 1L, , ),
bor3(nff <= 1L, , ))
expect_equal(or3s(nfg <= 9L, , ),
bor3(nfg <= 9L, , ))
expect_equal(or3s(nfh <= 0L, , d <= 0L),
bor3(nfh <= 0L, , d <= 0L))
expect_equal(or3s(nfi <= 1L, , h <= 1L),
bor3(nfi <= 1L, , h <= 1L))
expect_equal(or3s(nfj <= 9L, , c <= 9L),
bor3(nfj <= 9L, , c <= 9L))
expect_equal(or3s(nfk <= 0L, logi_u, ),
bor3(nfk <= 0L, logi_u, ))
expect_equal(or3s(nfl <= 1L, logi_c, ),
bor3(nfl <= 1L, logi_c, ))
expect_equal(or3s(nfm <= 9L, logi_c, ),
bor3(nfm <= 9L, logi_c, ))
expect_equal(or3s(nfn <= 0L, logi_e, c <= 0L),
bor3(nfn <= 0L, logi_e, c <= 0L))
expect_equal(or3s(nfo <= 1L, logi_b, r <= 1L),
bor3(nfo <= 1L, logi_b, r <= 1L))
expect_equal(or3s(nfp <= 9L, logi_l, x <= 9L),
bor3(nfp <= 9L, logi_l, x <= 9L))
expect_equal(or3s(nfq <= 0L, , ),
bor3(nfq <= 0L, , ))
expect_equal(or3s(nfr <= 1L, , ),
bor3(nfr <= 1L, , ))
expect_equal(or3s(nfs <= 9L, , ),
bor3(nfs <= 9L, , ))
expect_equal(or3s(nft <= 0L, , a == 0L),
bor3(nft <= 0L, , a == 0L))
expect_equal(or3s(nfu <= 1L, , h == 1L),
bor3(nfu <= 1L, , h == 1L))
expect_equal(or3s(nfv <= 9L, , c == 9L),
bor3(nfv <= 9L, , c == 9L))
expect_equal(or3s(nfw <= 0L, logi_x, ),
bor3(nfw <= 0L, logi_x, ))
expect_equal(or3s(nfx <= 1L, logi_t, ),
bor3(nfx <= 1L, logi_t, ))
expect_equal(or3s(nfy <= 9L, logi_j, ),
bor3(nfy <= 9L, logi_j, ))
expect_equal(or3s(nfz <= 0L, logi_o, n == 0L),
bor3(nfz <= 0L, logi_o, n == 0L))
expect_equal(or3s(nga <= 1L, logi_t, s == 1L),
bor3(nga <= 1L, logi_t, s == 1L))
expect_equal(or3s(ngb <= 9L, logi_c, h == 9L),
bor3(ngb <= 9L, logi_c, h == 9L))
expect_equal(or3s(ngc <= 0L, , ),
bor3(ngc <= 0L, , ))
expect_equal(or3s(ngd <= 1L, , ),
bor3(ngd <= 1L, , ))
expect_equal(or3s(nge <= 9L, , ),
bor3(nge <= 9L, , ))
expect_equal(or3s(ngf <= 0L, , n > 0L),
bor3(ngf <= 0L, , n > 0L))
expect_equal(or3s(ngg <= 1L, , p > 1L),
bor3(ngg <= 1L, , p > 1L))
expect_equal(or3s(ngh <= 9L, , a > 9L),
bor3(ngh <= 9L, , a > 9L))
expect_equal(or3s(ngi <= 0L, logi_w, ),
bor3(ngi <= 0L, logi_w, ))
expect_equal(or3s(ngj <= 1L, logi_n, ),
bor3(ngj <= 1L, logi_n, ))
expect_equal(or3s(ngk <= 9L, logi_s, ),
bor3(ngk <= 9L, logi_s, ))
expect_equal(or3s(ngl <= 0L, logi_f, p > 0L),
bor3(ngl <= 0L, logi_f, p > 0L))
expect_equal(or3s(ngm <= 1L, logi_q, r > 1L),
bor3(ngm <= 1L, logi_q, r > 1L))
expect_equal(or3s(ngn <= 9L, logi_p, e > 9L),
bor3(ngn <= 9L, logi_p, e > 9L))
expect_equal(or3s(ngo <= 0L, , ),
bor3(ngo <= 0L, , ))
expect_equal(or3s(ngp <= 1L, , ),
bor3(ngp <= 1L, , ))
expect_equal(or3s(ngq <= 9L, , ),
bor3(ngq <= 9L, , ))
expect_equal(or3s(ngr <= 0L, , z >= 0L),
bor3(ngr <= 0L, , z >= 0L))
expect_equal(or3s(ngs <= 1L, , m >= 1L),
bor3(ngs <= 1L, , m >= 1L))
expect_equal(or3s(ngt <= 9L, , e >= 9L),
bor3(ngt <= 9L, , e >= 9L))
expect_equal(or3s(ngu <= 0L, logi_k, ),
bor3(ngu <= 0L, logi_k, ))
expect_equal(or3s(ngv <= 1L, logi_l, ),
bor3(ngv <= 1L, logi_l, ))
expect_equal(or3s(ngw <= 9L, logi_b, ),
bor3(ngw <= 9L, logi_b, ))
expect_equal(or3s(ngx <= 0L, logi_v, n >= 0L),
bor3(ngx <= 0L, logi_v, n >= 0L))
expect_equal(or3s(ngy <= 1L, logi_c, p >= 1L),
bor3(ngy <= 1L, logi_c, p >= 1L))
expect_equal(or3s(ngz <= 9L, logi_i, i >= 9L),
bor3(ngz <= 9L, logi_i, i >= 9L))
expect_equal(or3s(nha <= 0L, , ),
bor3(nha <= 0L, , ))
expect_equal(or3s(nhb <= 1L, , ),
bor3(nhb <= 1L, , ))
expect_equal(or3s(nhc <= 9L, , ),
bor3(nhc <= 9L, , ))
expect_equal(or3s(nhd <= 0L, , logi_h),
bor3(nhd <= 0L, , logi_h))
expect_equal(or3s(nhe <= 1L, , logi_b),
bor3(nhe <= 1L, , logi_b))
expect_equal(or3s(nhf <= 9L, , logi_u),
bor3(nhf <= 9L, , logi_u))
expect_equal(or3s(nhg <= 0L, !logi_u, ),
bor3(nhg <= 0L, !logi_u, ))
expect_equal(or3s(nhh <= 1L, !logi_j, ),
bor3(nhh <= 1L, !logi_j, ))
expect_equal(or3s(nhi <= 9L, !logi_b, ),
bor3(nhi <= 9L, !logi_b, ))
expect_equal(or3s(nhj <= 0L, !logi_n, logi_p),
bor3(nhj <= 0L, !logi_n, logi_p))
expect_equal(or3s(nhk <= 1L, !logi_o, logi_i),
bor3(nhk <= 1L, !logi_o, logi_i))
expect_equal(or3s(nhl <= 9L, !logi_j, logi_e),
bor3(nhl <= 9L, !logi_j, logi_e))
expect_equal(or3s(nhm <= 0L, , ),
bor3(nhm <= 0L, , ))
expect_equal(or3s(nhn <= 1L, , ),
bor3(nhn <= 1L, , ))
expect_equal(or3s(nho <= 9L, , ),
bor3(nho <= 9L, , ))
expect_equal(or3s(nhp <= 0L, , !logi_s),
bor3(nhp <= 0L, , !logi_s))
expect_equal(or3s(nhq <= 1L, , !logi_w),
bor3(nhq <= 1L, , !logi_w))
expect_equal(or3s(nhr <= 9L, , !logi_w),
bor3(nhr <= 9L, , !logi_w))
expect_equal(or3s(nhs <= 0L, !logi_w, ),
bor3(nhs <= 0L, !logi_w, ))
expect_equal(or3s(nht <= 1L, !logi_b, ),
bor3(nht <= 1L, !logi_b, ))
expect_equal(or3s(nhu <= 9L, !logi_j, ),
bor3(nhu <= 9L, !logi_j, ))
expect_equal(or3s(nhv <= 0L, !logi_j, !logi_y),
bor3(nhv <= 0L, !logi_j, !logi_y))
expect_equal(or3s(nhw <= 1L, !logi_e, !logi_k),
bor3(nhw <= 1L, !logi_e, !logi_k))
expect_equal(or3s(nhx <= 9L, !logi_y, !logi_w),
bor3(nhx <= 9L, !logi_y, !logi_w))
expect_equal(or3s(nhy <= 0L, , ),
bor3(nhy <= 0L, , ))
expect_equal(or3s(nhz <= 1L, , ),
bor3(nhz <= 1L, , ))
expect_equal(or3s(nia <= 9L, , ),
bor3(nia <= 9L, , ))
expect_equal(or3s(nib <= 0L, , j != 0L),
bor3(nib <= 0L, , j != 0L))
expect_equal(or3s(nic <= 1L, , d != 1L),
bor3(nic <= 1L, , d != 1L))
expect_equal(or3s(nid <= 9L, , e != 9L),
bor3(nid <= 9L, , e != 9L))
expect_equal(or3s(nie <= 0L, !logi_q, ),
bor3(nie <= 0L, !logi_q, ))
expect_equal(or3s(nif <= 1L, !logi_u, ),
bor3(nif <= 1L, !logi_u, ))
expect_equal(or3s(nig <= 9L, !logi_y, ),
bor3(nig <= 9L, !logi_y, ))
expect_equal(or3s(nih <= 0L, !logi_h, e != 0L),
bor3(nih <= 0L, !logi_h, e != 0L))
expect_equal(or3s(nii <= 1L, !logi_z, i != 1L),
bor3(nii <= 1L, !logi_z, i != 1L))
expect_equal(or3s(nij <= 9L, !logi_o, s != 9L),
bor3(nij <= 9L, !logi_o, s != 9L))
expect_equal(or3s(nik <= 0L, , ),
bor3(nik <= 0L, , ))
expect_equal(or3s(nil <= 1L, , ),
bor3(nil <= 1L, , ))
expect_equal(or3s(nim <= 9L, , ),
bor3(nim <= 9L, , ))
expect_equal(or3s(nin <= 0L, , k %between% c(-1L, 1L)),
bor3(nin <= 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(nio <= 1L, , q %between% c(-1L, 1L)),
bor3(nio <= 1L, , q %between% c(-1L, 1L)))
expect_equal(or3s(nip <= 9L, , c %between% c(-1L, 1L)),
bor3(nip <= 9L, , c %between% c(-1L, 1L)))
expect_equal(or3s(niq <= 0L, !logi_a, ),
bor3(niq <= 0L, !logi_a, ))
expect_equal(or3s(nir <= 1L, !logi_h, ),
bor3(nir <= 1L, !logi_h, ))
expect_equal(or3s(nis <= 9L, !logi_w, ),
bor3(nis <= 9L, !logi_w, ))
expect_equal(or3s(nit <= 0L, !logi_x, w %between% c(-1L, 1L)),
bor3(nit <= 0L, !logi_x, w %between% c(-1L, 1L)))
expect_equal(or3s(niu <= 1L, !logi_k, b %between% c(-1L, 1L)),
bor3(niu <= 1L, !logi_k, b %between% c(-1L, 1L)))
expect_equal(or3s(niv <= 9L, !logi_k, w %between% c(-1L, 1L)),
bor3(niv <= 9L, !logi_k, w %between% c(-1L, 1L)))
expect_equal(or3s(niw <= 0L, , ),
bor3(niw <= 0L, , ))
expect_equal(or3s(nix <= 1L, , ),
bor3(nix <= 1L, , ))
expect_equal(or3s(niy <= 9L, , ),
bor3(niy <= 9L, , ))
expect_equal(or3s(niz <= 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(niz <= 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nja <= 1L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nja <= 1L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(njb <= 9L, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(njb <= 9L, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(njc <= 0L, !logi_t, ),
bor3(njc <= 0L, !logi_t, ))
expect_equal(or3s(njd <= 1L, !logi_j, ),
bor3(njd <= 1L, !logi_j, ))
expect_equal(or3s(nje <= 9L, !logi_z, ),
bor3(nje <= 9L, !logi_z, ))
expect_equal(or3s(njf <= 0L, !logi_h, w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(njf <= 0L, !logi_h, w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(njg <= 1L, !logi_o, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(njg <= 1L, !logi_o, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(njh <= 9L, !logi_w, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(njh <= 9L, !logi_w, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nji <= 0L, , ),
bor3(nji <= 0L, , ))
expect_equal(or3s(njj <= 1L, , ),
bor3(njj <= 1L, , ))
expect_equal(or3s(njk <= 9L, , ),
bor3(njk <= 9L, , ))
expect_equal(or3s(njl <= 0L, , o %in% 1:4),
bor3(njl <= 0L, , o %in% 1:4))
expect_equal(or3s(njm <= 1L, , j %in% 1:4),
bor3(njm <= 1L, , j %in% 1:4))
expect_equal(or3s(njn <= 9L, , i %in% 1:4),
bor3(njn <= 9L, , i %in% 1:4))
expect_equal(or3s(njo <= 0L, !logi_b, ),
bor3(njo <= 0L, !logi_b, ))
expect_equal(or3s(njp <= 1L, !logi_u, ),
bor3(njp <= 1L, !logi_u, ))
expect_equal(or3s(njq <= 9L, !logi_k, ),
bor3(njq <= 9L, !logi_k, ))
expect_equal(or3s(njr <= 0L, !logi_d, y %in% 1:4),
bor3(njr <= 0L, !logi_d, y %in% 1:4))
expect_equal(or3s(njs <= 1L, !logi_z, z %in% 1:4),
bor3(njs <= 1L, !logi_z, z %in% 1:4))
expect_equal(or3s(njt <= 9L, !logi_c, a %in% 1:4),
bor3(njt <= 9L, !logi_c, a %in% 1:4))
expect_equal(or3s(nju <= 0L, , ),
bor3(nju <= 0L, , ))
expect_equal(or3s(njv <= 1L, , ),
bor3(njv <= 1L, , ))
expect_equal(or3s(njw <= 9L, , ),
bor3(njw <= 9L, , ))
expect_equal(or3s(njx <= 0L, , k < 0L),
bor3(njx <= 0L, , k < 0L))
expect_equal(or3s(njy <= 1L, , b < 1L),
bor3(njy <= 1L, , b < 1L))
expect_equal(or3s(njz <= 9L, , a < 9L),
bor3(njz <= 9L, , a < 9L))
expect_equal(or3s(nka <= 0L, !logi_i, ),
bor3(nka <= 0L, !logi_i, ))
expect_equal(or3s(nkb <= 1L, !logi_j, ),
bor3(nkb <= 1L, !logi_j, ))
expect_equal(or3s(nkc <= 9L, !logi_j, ),
bor3(nkc <= 9L, !logi_j, ))
expect_equal(or3s(nkd <= 0L, !logi_d, t < 0L),
bor3(nkd <= 0L, !logi_d, t < 0L))
expect_equal(or3s(nke <= 1L, !logi_j, l < 1L),
bor3(nke <= 1L, !logi_j, l < 1L))
expect_equal(or3s(nkf <= 9L, !logi_n, b < 9L),
bor3(nkf <= 9L, !logi_n, b < 9L))
expect_equal(or3s(nkg <= 0L, , ),
bor3(nkg <= 0L, , ))
expect_equal(or3s(nkh <= 1L, , ),
bor3(nkh <= 1L, , ))
expect_equal(or3s(nki <= 9L, , ),
bor3(nki <= 9L, , ))
expect_equal(or3s(nkj <= 0L, , y <= 0L),
bor3(nkj <= 0L, , y <= 0L))
expect_equal(or3s(nkk <= 1L, , p <= 1L),
bor3(nkk <= 1L, , p <= 1L))
expect_equal(or3s(nkl <= 9L, , r <= 9L),
bor3(nkl <= 9L, , r <= 9L))
expect_equal(or3s(nkm <= 0L, !logi_c, ),
bor3(nkm <= 0L, !logi_c, ))
expect_equal(or3s(nkn <= 1L, !logi_c, ),
bor3(nkn <= 1L, !logi_c, ))
expect_equal(or3s(nko <= 9L, !logi_w, ),
bor3(nko <= 9L, !logi_w, ))
expect_equal(or3s(nkp <= 0L, !logi_c, n <= 0L),
bor3(nkp <= 0L, !logi_c, n <= 0L))
expect_equal(or3s(nkq <= 1L, !logi_a, m <= 1L),
bor3(nkq <= 1L, !logi_a, m <= 1L))
expect_equal(or3s(nkr <= 9L, !logi_e, o <= 9L),
bor3(nkr <= 9L, !logi_e, o <= 9L))
expect_equal(or3s(nks <= 0L, , ),
bor3(nks <= 0L, , ))
expect_equal(or3s(nkt <= 1L, , ),
bor3(nkt <= 1L, , ))
expect_equal(or3s(nku <= 9L, , ),
bor3(nku <= 9L, , ))
expect_equal(or3s(nkv <= 0L, , h == 0L),
bor3(nkv <= 0L, , h == 0L))
expect_equal(or3s(nkw <= 1L, , u == 1L),
bor3(nkw <= 1L, , u == 1L))
expect_equal(or3s(nkx <= 9L, , k == 9L),
bor3(nkx <= 9L, , k == 9L))
expect_equal(or3s(nky <= 0L, !logi_e, ),
bor3(nky <= 0L, !logi_e, ))
expect_equal(or3s(nkz <= 1L, !logi_z, ),
bor3(nkz <= 1L, !logi_z, ))
expect_equal(or3s(nla <= 9L, !logi_p, ),
bor3(nla <= 9L, !logi_p, ))
expect_equal(or3s(nlb <= 0L, !logi_h, n == 0L),
bor3(nlb <= 0L, !logi_h, n == 0L))
expect_equal(or3s(nlc <= 1L, !logi_b, j == 1L),
bor3(nlc <= 1L, !logi_b, j == 1L))
expect_equal(or3s(nld <= 9L, !logi_t, f == 9L),
bor3(nld <= 9L, !logi_t, f == 9L))
expect_equal(or3s(nle <= 0L, , ),
bor3(nle <= 0L, , ))
expect_equal(or3s(nlf <= 1L, , ),
bor3(nlf <= 1L, , ))
expect_equal(or3s(nlg <= 9L, , ),
bor3(nlg <= 9L, , ))
expect_equal(or3s(nlh <= 0L, , y > 0L),
bor3(nlh <= 0L, , y > 0L))
expect_equal(or3s(nli <= 1L, , v > 1L),
bor3(nli <= 1L, , v > 1L))
expect_equal(or3s(nlj <= 9L, , d > 9L),
bor3(nlj <= 9L, , d > 9L))
expect_equal(or3s(nlk <= 0L, !logi_q, ),
bor3(nlk <= 0L, !logi_q, ))
expect_equal(or3s(nll <= 1L, !logi_e, ),
bor3(nll <= 1L, !logi_e, ))
expect_equal(or3s(nlm <= 9L, !logi_z, ),
bor3(nlm <= 9L, !logi_z, ))
expect_equal(or3s(nln <= 0L, !logi_t, i > 0L),
bor3(nln <= 0L, !logi_t, i > 0L))
expect_equal(or3s(nlo <= 1L, !logi_w, h > 1L),
bor3(nlo <= 1L, !logi_w, h > 1L))
expect_equal(or3s(nlp <= 9L, !logi_p, o > 9L),
bor3(nlp <= 9L, !logi_p, o > 9L))
expect_equal(or3s(nlq <= 0L, , ),
bor3(nlq <= 0L, , ))
expect_equal(or3s(nlr <= 1L, , ),
bor3(nlr <= 1L, , ))
expect_equal(or3s(nls <= 9L, , ),
bor3(nls <= 9L, , ))
expect_equal(or3s(nlt <= 0L, , h >= 0L),
bor3(nlt <= 0L, , h >= 0L))
expect_equal(or3s(nlu <= 1L, , z >= 1L),
bor3(nlu <= 1L, , z >= 1L))
expect_equal(or3s(nlv <= 9L, , g >= 9L),
bor3(nlv <= 9L, , g >= 9L))
expect_equal(or3s(nlw <= 0L, !logi_a, ),
bor3(nlw <= 0L, !logi_a, ))
expect_equal(or3s(nlx <= 1L, !logi_h, ),
bor3(nlx <= 1L, !logi_h, ))
expect_equal(or3s(nly <= 9L, !logi_n, ),
bor3(nly <= 9L, !logi_n, ))
expect_equal(or3s(nlz <= 0L, !logi_u, f >= 0L),
bor3(nlz <= 0L, !logi_u, f >= 0L))
expect_equal(or3s(nma <= 1L, !logi_r, g >= 1L),
bor3(nma <= 1L, !logi_r, g >= 1L))
expect_equal(or3s(nmb <= 9L, !logi_c, b >= 9L),
bor3(nmb <= 9L, !logi_c, b >= 9L))
expect_equal(or3s(nmc <= 0L, , ),
bor3(nmc <= 0L, , ))
expect_equal(or3s(nmd <= 1L, , ),
bor3(nmd <= 1L, , ))
expect_equal(or3s(nme <= 9L, , ),
bor3(nme <= 9L, , ))
expect_equal(or3s(nmf <= 0L, , logi_n),
bor3(nmf <= 0L, , logi_n))
expect_equal(or3s(nmg <= 1L, , logi_m),
bor3(nmg <= 1L, , logi_m))
expect_equal(or3s(nmh <= 9L, , logi_z),
bor3(nmh <= 9L, , logi_z))
expect_equal(or3s(nmi <= 0L, z != 0L, ),
bor3(nmi <= 0L, z != 0L, ))
expect_equal(or3s(nmj <= 1L, d != 1L, ),
bor3(nmj <= 1L, d != 1L, ))
expect_equal(or3s(nmk <= 9L, r != 9L, ),
bor3(nmk <= 9L, r != 9L, ))
expect_equal(or3s(nml <= 0L, a != 0L, logi_m),
bor3(nml <= 0L, a != 0L, logi_m))
expect_equal(or3s(nmm <= 1L, u != 1L, logi_c),
bor3(nmm <= 1L, u != 1L, logi_c))
expect_equal(or3s(nmn <= 9L, s != 9L, logi_s),
bor3(nmn <= 9L, s != 9L, logi_s))
expect_equal(or3s(nmo <= 0L, , ),
bor3(nmo <= 0L, , ))
expect_equal(or3s(nmp <= 1L, , ),
bor3(nmp <= 1L, , ))
expect_equal(or3s(nmq <= 9L, , ),
bor3(nmq <= 9L, , ))
expect_equal(or3s(nmr <= 0L, , !logi_d),
bor3(nmr <= 0L, , !logi_d))
expect_equal(or3s(nms <= 1L, , !logi_t),
bor3(nms <= 1L, , !logi_t))
expect_equal(or3s(nmt <= 9L, , !logi_e),
bor3(nmt <= 9L, , !logi_e))
expect_equal(or3s(nmu <= 0L, l != 0L, ),
bor3(nmu <= 0L, l != 0L, ))
expect_equal(or3s(nmv <= 1L, n != 1L, ),
bor3(nmv <= 1L, n != 1L, ))
expect_equal(or3s(nmw <= 9L, f != 9L, ),
bor3(nmw <= 9L, f != 9L, ))
expect_equal(or3s(nmx <= 0L, s != 0L, !logi_o),
bor3(nmx <= 0L, s != 0L, !logi_o))
expect_equal(or3s(nmy <= 1L, e != 1L, !logi_l),
bor3(nmy <= 1L, e != 1L, !logi_l))
expect_equal(or3s(nmz <= 9L, d != 9L, !logi_r),
bor3(nmz <= 9L, d != 9L, !logi_r))
expect_equal(or3s(nna <= 0L, , ),
bor3(nna <= 0L, , ))
expect_equal(or3s(nnb <= 1L, , ),
bor3(nnb <= 1L, , ))
expect_equal(or3s(nnc <= 9L, , ),
bor3(nnc <= 9L, , ))
expect_equal(or3s(nnd <= 0L, , r != 0L),
bor3(nnd <= 0L, , r != 0L))
expect_equal(or3s(nne <= 1L, , l != 1L),
bor3(nne <= 1L, , l != 1L))
expect_equal(or3s(nnf <= 9L, , u != 9L),
bor3(nnf <= 9L, , u != 9L))
expect_equal(or3s(nng <= 0L, h != 0L, ),
bor3(nng <= 0L, h != 0L, ))
expect_equal(or3s(nnh <= 1L, r != 1L, ),
bor3(nnh <= 1L, r != 1L, ))
expect_equal(or3s(nni <= 9L, j != 9L, ),
bor3(nni <= 9L, j != 9L, ))
expect_equal(or3s(nnj <= 0L, r != 0L, s != 0L),
bor3(nnj <= 0L, r != 0L, s != 0L))
expect_equal(or3s(nnk <= 1L, r != 1L, i != 1L),
bor3(nnk <= 1L, r != 1L, i != 1L))
expect_equal(or3s(nnl <= 9L, m != 9L, p != 9L),
bor3(nnl <= 9L, m != 9L, p != 9L))
expect_equal(or3s(nnm <= 0L, , ),
bor3(nnm <= 0L, , ))
expect_equal(or3s(nnn <= 1L, , ),
bor3(nnn <= 1L, , ))
expect_equal(or3s(nno <= 9L, , ),
bor3(nno <= 9L, , ))
expect_equal(or3s(nnp <= 0L, , z %between% c(-1L, 1L)),
bor3(nnp <= 0L, , z %between% c(-1L, 1L)))
expect_equal(or3s(nnq <= 1L, , m %between% c(-1L, 1L)),
bor3(nnq <= 1L, , m %between% c(-1L, 1L)))
expect_equal(or3s(nnr <= 9L, , k %between% c(-1L, 1L)),
bor3(nnr <= 9L, , k %between% c(-1L, 1L)))
expect_equal(or3s(nns <= 0L, f != 0L, ),
bor3(nns <= 0L, f != 0L, ))
expect_equal(or3s(nnt <= 1L, f != 1L, ),
bor3(nnt <= 1L, f != 1L, ))
expect_equal(or3s(nnu <= 9L, e != 9L, ),
bor3(nnu <= 9L, e != 9L, ))
expect_equal(or3s(nnv <= 0L, b != 0L, c %between% c(-1L, 1L)),
bor3(nnv <= 0L, b != 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(nnw <= 1L, q != 1L, g %between% c(-1L, 1L)),
bor3(nnw <= 1L, q != 1L, g %between% c(-1L, 1L)))
expect_equal(or3s(nnx <= 9L, p != 9L, s %between% c(-1L, 1L)),
bor3(nnx <= 9L, p != 9L, s %between% c(-1L, 1L)))
expect_equal(or3s(nny <= 0L, , ),
bor3(nny <= 0L, , ))
expect_equal(or3s(nnz <= 1L, , ),
bor3(nnz <= 1L, , ))
expect_equal(or3s(noa <= 9L, , ),
bor3(noa <= 9L, , ))
expect_equal(or3s(nob <= 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nob <= 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(noc <= 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(noc <= 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nod <= 9L, , v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nod <= 9L, , v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(noe <= 0L, k != 0L, ),
bor3(noe <= 0L, k != 0L, ))
expect_equal(or3s(nof <= 1L, l != 1L, ),
bor3(nof <= 1L, l != 1L, ))
expect_equal(or3s(nog <= 9L, c != 9L, ),
bor3(nog <= 9L, c != 9L, ))
expect_equal(or3s(noh <= 0L, z != 0L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(noh <= 0L, z != 0L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(noi <= 1L, t != 1L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(noi <= 1L, t != 1L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(noj <= 9L, e != 9L, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(noj <= 9L, e != 9L, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nok <= 0L, , ),
bor3(nok <= 0L, , ))
expect_equal(or3s(nol <= 1L, , ),
bor3(nol <= 1L, , ))
expect_equal(or3s(nom <= 9L, , ),
bor3(nom <= 9L, , ))
expect_equal(or3s(non <= 0L, , s %in% 1:4),
bor3(non <= 0L, , s %in% 1:4))
expect_equal(or3s(noo <= 1L, , j %in% 1:4),
bor3(noo <= 1L, , j %in% 1:4))
expect_equal(or3s(nop <= 9L, , c %in% 1:4),
bor3(nop <= 9L, , c %in% 1:4))
expect_equal(or3s(noq <= 0L, i != 0L, ),
bor3(noq <= 0L, i != 0L, ))
expect_equal(or3s(nor <= 1L, h != 1L, ),
bor3(nor <= 1L, h != 1L, ))
expect_equal(or3s(nos <= 9L, s != 9L, ),
bor3(nos <= 9L, s != 9L, ))
expect_equal(or3s(not <= 0L, j != 0L, g %in% 1:4),
bor3(not <= 0L, j != 0L, g %in% 1:4))
expect_equal(or3s(nou <= 1L, c != 1L, d %in% 1:4),
bor3(nou <= 1L, c != 1L, d %in% 1:4))
expect_equal(or3s(nov <= 9L, h != 9L, z %in% 1:4),
bor3(nov <= 9L, h != 9L, z %in% 1:4))
expect_equal(or3s(now <= 0L, , ),
bor3(now <= 0L, , ))
expect_equal(or3s(nox <= 1L, , ),
bor3(nox <= 1L, , ))
expect_equal(or3s(noy <= 9L, , ),
bor3(noy <= 9L, , ))
expect_equal(or3s(noz <= 0L, , g < 0L),
bor3(noz <= 0L, , g < 0L))
expect_equal(or3s(npa <= 1L, , h < 1L),
bor3(npa <= 1L, , h < 1L))
expect_equal(or3s(npb <= 9L, , q < 9L),
bor3(npb <= 9L, , q < 9L))
expect_equal(or3s(npc <= 0L, h != 0L, ),
bor3(npc <= 0L, h != 0L, ))
expect_equal(or3s(npd <= 1L, m != 1L, ),
bor3(npd <= 1L, m != 1L, ))
expect_equal(or3s(npe <= 9L, w != 9L, ),
bor3(npe <= 9L, w != 9L, ))
expect_equal(or3s(npf <= 0L, q != 0L, v < 0L),
bor3(npf <= 0L, q != 0L, v < 0L))
expect_equal(or3s(npg <= 1L, e != 1L, n < 1L),
bor3(npg <= 1L, e != 1L, n < 1L))
expect_equal(or3s(nph <= 9L, u != 9L, t < 9L),
bor3(nph <= 9L, u != 9L, t < 9L))
expect_equal(or3s(npi <= 0L, , ),
bor3(npi <= 0L, , ))
expect_equal(or3s(npj <= 1L, , ),
bor3(npj <= 1L, , ))
expect_equal(or3s(npk <= 9L, , ),
bor3(npk <= 9L, , ))
expect_equal(or3s(npl <= 0L, , x <= 0L),
bor3(npl <= 0L, , x <= 0L))
expect_equal(or3s(npm <= 1L, , l <= 1L),
bor3(npm <= 1L, , l <= 1L))
expect_equal(or3s(npn <= 9L, , e <= 9L),
bor3(npn <= 9L, , e <= 9L))
expect_equal(or3s(npo <= 0L, r != 0L, ),
bor3(npo <= 0L, r != 0L, ))
expect_equal(or3s(npp <= 1L, d != 1L, ),
bor3(npp <= 1L, d != 1L, ))
expect_equal(or3s(npq <= 9L, n != 9L, ),
bor3(npq <= 9L, n != 9L, ))
expect_equal(or3s(npr <= 0L, s != 0L, z <= 0L),
bor3(npr <= 0L, s != 0L, z <= 0L))
expect_equal(or3s(nps <= 1L, h != 1L, k <= 1L),
bor3(nps <= 1L, h != 1L, k <= 1L))
expect_equal(or3s(npt <= 9L, l != 9L, b <= 9L),
bor3(npt <= 9L, l != 9L, b <= 9L))
expect_equal(or3s(npu <= 0L, , ),
bor3(npu <= 0L, , ))
expect_equal(or3s(npv <= 1L, , ),
bor3(npv <= 1L, , ))
expect_equal(or3s(npw <= 9L, , ),
bor3(npw <= 9L, , ))
expect_equal(or3s(npx <= 0L, , x == 0L),
bor3(npx <= 0L, , x == 0L))
expect_equal(or3s(npy <= 1L, , s == 1L),
bor3(npy <= 1L, , s == 1L))
expect_equal(or3s(npz <= 9L, , t == 9L),
bor3(npz <= 9L, , t == 9L))
expect_equal(or3s(nqa <= 0L, s != 0L, ),
bor3(nqa <= 0L, s != 0L, ))
expect_equal(or3s(nqb <= 1L, o != 1L, ),
bor3(nqb <= 1L, o != 1L, ))
expect_equal(or3s(nqc <= 9L, z != 9L, ),
bor3(nqc <= 9L, z != 9L, ))
expect_equal(or3s(nqd <= 0L, i != 0L, t == 0L),
bor3(nqd <= 0L, i != 0L, t == 0L))
expect_equal(or3s(nqe <= 1L, a != 1L, l == 1L),
bor3(nqe <= 1L, a != 1L, l == 1L))
expect_equal(or3s(nqf <= 9L, j != 9L, i == 9L),
bor3(nqf <= 9L, j != 9L, i == 9L))
expect_equal(or3s(nqg <= 0L, , ),
bor3(nqg <= 0L, , ))
expect_equal(or3s(nqh <= 1L, , ),
bor3(nqh <= 1L, , ))
expect_equal(or3s(nqi <= 9L, , ),
bor3(nqi <= 9L, , ))
expect_equal(or3s(nqj <= 0L, , n > 0L),
bor3(nqj <= 0L, , n > 0L))
expect_equal(or3s(nqk <= 1L, , l > 1L),
bor3(nqk <= 1L, , l > 1L))
expect_equal(or3s(nql <= 9L, , y > 9L),
bor3(nql <= 9L, , y > 9L))
expect_equal(or3s(nqm <= 0L, n != 0L, ),
bor3(nqm <= 0L, n != 0L, ))
expect_equal(or3s(nqn <= 1L, t != 1L, ),
bor3(nqn <= 1L, t != 1L, ))
expect_equal(or3s(nqo <= 9L, o != 9L, ),
bor3(nqo <= 9L, o != 9L, ))
expect_equal(or3s(nqp <= 0L, y != 0L, v > 0L),
bor3(nqp <= 0L, y != 0L, v > 0L))
expect_equal(or3s(nqq <= 1L, z != 1L, n > 1L),
bor3(nqq <= 1L, z != 1L, n > 1L))
expect_equal(or3s(nqr <= 9L, n != 9L, g > 9L),
bor3(nqr <= 9L, n != 9L, g > 9L))
expect_equal(or3s(nqs <= 0L, , ),
bor3(nqs <= 0L, , ))
expect_equal(or3s(nqt <= 1L, , ),
bor3(nqt <= 1L, , ))
expect_equal(or3s(nqu <= 9L, , ),
bor3(nqu <= 9L, , ))
expect_equal(or3s(nqv <= 0L, , f >= 0L),
bor3(nqv <= 0L, , f >= 0L))
expect_equal(or3s(nqw <= 1L, , s >= 1L),
bor3(nqw <= 1L, , s >= 1L))
expect_equal(or3s(nqx <= 9L, , i >= 9L),
bor3(nqx <= 9L, , i >= 9L))
expect_equal(or3s(nqy <= 0L, p != 0L, ),
bor3(nqy <= 0L, p != 0L, ))
expect_equal(or3s(nqz <= 1L, v != 1L, ),
bor3(nqz <= 1L, v != 1L, ))
expect_equal(or3s(nra <= 9L, f != 9L, ),
bor3(nra <= 9L, f != 9L, ))
expect_equal(or3s(nrb <= 0L, u != 0L, s >= 0L),
bor3(nrb <= 0L, u != 0L, s >= 0L))
expect_equal(or3s(nrc <= 1L, y != 1L, n >= 1L),
bor3(nrc <= 1L, y != 1L, n >= 1L))
expect_equal(or3s(nrd <= 9L, a != 9L, h >= 9L),
bor3(nrd <= 9L, a != 9L, h >= 9L))
expect_equal(or3s(nre <= 0L, , ),
bor3(nre <= 0L, , ))
expect_equal(or3s(nrf <= 1L, , ),
bor3(nrf <= 1L, , ))
expect_equal(or3s(nrg <= 9L, , ),
bor3(nrg <= 9L, , ))
expect_equal(or3s(nrh <= 0L, , logi_w),
bor3(nrh <= 0L, , logi_w))
expect_equal(or3s(nri <= 1L, , logi_u),
bor3(nri <= 1L, , logi_u))
expect_equal(or3s(nrj <= 9L, , logi_a),
bor3(nrj <= 9L, , logi_a))
expect_equal(or3s(nrk <= 0L, m %between% c(-1L, 1L), ),
bor3(nrk <= 0L, m %between% c(-1L, 1L), ))
expect_equal(or3s(nrl <= 1L, f %between% c(-1L, 1L), ),
bor3(nrl <= 1L, f %between% c(-1L, 1L), ))
expect_equal(or3s(nrm <= 9L, i %between% c(-1L, 1L), ),
bor3(nrm <= 9L, i %between% c(-1L, 1L), ))
expect_equal(or3s(nrn <= 0L, q %between% c(-1L, 1L), logi_v),
bor3(nrn <= 0L, q %between% c(-1L, 1L), logi_v))
expect_equal(or3s(nro <= 1L, j %between% c(-1L, 1L), logi_w),
bor3(nro <= 1L, j %between% c(-1L, 1L), logi_w))
expect_equal(or3s(nrp <= 9L, d %between% c(-1L, 1L), logi_b),
bor3(nrp <= 9L, d %between% c(-1L, 1L), logi_b))
expect_equal(or3s(nrq <= 0L, , ),
bor3(nrq <= 0L, , ))
expect_equal(or3s(nrr <= 1L, , ),
bor3(nrr <= 1L, , ))
expect_equal(or3s(nrs <= 9L, , ),
bor3(nrs <= 9L, , ))
expect_equal(or3s(nrt <= 0L, , !logi_d),
bor3(nrt <= 0L, , !logi_d))
expect_equal(or3s(nru <= 1L, , !logi_g),
bor3(nru <= 1L, , !logi_g))
expect_equal(or3s(nrv <= 9L, , !logi_a),
bor3(nrv <= 9L, , !logi_a))
expect_equal(or3s(nrw <= 0L, o %between% c(-1L, 1L), ),
bor3(nrw <= 0L, o %between% c(-1L, 1L), ))
expect_equal(or3s(nrx <= 1L, k %between% c(-1L, 1L), ),
bor3(nrx <= 1L, k %between% c(-1L, 1L), ))
expect_equal(or3s(nry <= 9L, g %between% c(-1L, 1L), ),
bor3(nry <= 9L, g %between% c(-1L, 1L), ))
expect_equal(or3s(nrz <= 0L, l %between% c(-1L, 1L), !logi_u),
bor3(nrz <= 0L, l %between% c(-1L, 1L), !logi_u))
expect_equal(or3s(nsa <= 1L, v %between% c(-1L, 1L), !logi_i),
bor3(nsa <= 1L, v %between% c(-1L, 1L), !logi_i))
expect_equal(or3s(nsb <= 9L, g %between% c(-1L, 1L), !logi_w),
bor3(nsb <= 9L, g %between% c(-1L, 1L), !logi_w))
expect_equal(or3s(nsc <= 0L, , ),
bor3(nsc <= 0L, , ))
expect_equal(or3s(nsd <= 1L, , ),
bor3(nsd <= 1L, , ))
expect_equal(or3s(nse <= 9L, , ),
bor3(nse <= 9L, , ))
expect_equal(or3s(nsf <= 0L, , n != 0L),
bor3(nsf <= 0L, , n != 0L))
expect_equal(or3s(nsg <= 1L, , a != 1L),
bor3(nsg <= 1L, , a != 1L))
expect_equal(or3s(nsh <= 9L, , v != 9L),
bor3(nsh <= 9L, , v != 9L))
expect_equal(or3s(nsi <= 0L, i %between% c(-1L, 1L), ),
bor3(nsi <= 0L, i %between% c(-1L, 1L), ))
expect_equal(or3s(nsj <= 1L, p %between% c(-1L, 1L), ),
bor3(nsj <= 1L, p %between% c(-1L, 1L), ))
expect_equal(or3s(nsk <= 9L, l %between% c(-1L, 1L), ),
bor3(nsk <= 9L, l %between% c(-1L, 1L), ))
expect_equal(or3s(nsl <= 0L, f %between% c(-1L, 1L), d != 0L),
bor3(nsl <= 0L, f %between% c(-1L, 1L), d != 0L))
expect_equal(or3s(nsm <= 1L, f %between% c(-1L, 1L), y != 1L),
bor3(nsm <= 1L, f %between% c(-1L, 1L), y != 1L))
expect_equal(or3s(nsn <= 9L, b %between% c(-1L, 1L), w != 9L),
bor3(nsn <= 9L, b %between% c(-1L, 1L), w != 9L))
expect_equal(or3s(nso <= 0L, , ),
bor3(nso <= 0L, , ))
expect_equal(or3s(nsp <= 1L, , ),
bor3(nsp <= 1L, , ))
expect_equal(or3s(nsq <= 9L, , ),
bor3(nsq <= 9L, , ))
expect_equal(or3s(nsr <= 0L, , g %between% c(-1L, 1L)),
bor3(nsr <= 0L, , g %between% c(-1L, 1L)))
expect_equal(or3s(nss <= 1L, , e %between% c(-1L, 1L)),
bor3(nss <= 1L, , e %between% c(-1L, 1L)))
expect_equal(or3s(nst <= 9L, , a %between% c(-1L, 1L)),
bor3(nst <= 9L, , a %between% c(-1L, 1L)))
expect_equal(or3s(nsu <= 0L, b %between% c(-1L, 1L), ),
bor3(nsu <= 0L, b %between% c(-1L, 1L), ))
expect_equal(or3s(nsv <= 1L, l %between% c(-1L, 1L), ),
bor3(nsv <= 1L, l %between% c(-1L, 1L), ))
expect_equal(or3s(nsw <= 9L, c %between% c(-1L, 1L), ),
bor3(nsw <= 9L, c %between% c(-1L, 1L), ))
expect_equal(or3s(nsx <= 0L, c %between% c(-1L, 1L), f %between% c(-1L, 1L)),
bor3(nsx <= 0L, c %between% c(-1L, 1L), f %between% c(-1L, 1L)))
expect_equal(or3s(nsy <= 1L, o %between% c(-1L, 1L), y %between% c(-1L, 1L)),
bor3(nsy <= 1L, o %between% c(-1L, 1L), y %between% c(-1L, 1L)))
expect_equal(or3s(nsz <= 9L, k %between% c(-1L, 1L), g %between% c(-1L, 1L)),
bor3(nsz <= 9L, k %between% c(-1L, 1L), g %between% c(-1L, 1L)))
expect_equal(or3s(nta <= 0L, , ),
bor3(nta <= 0L, , ))
expect_equal(or3s(ntb <= 1L, , ),
bor3(ntb <= 1L, , ))
expect_equal(or3s(ntc <= 9L, , ),
bor3(ntc <= 9L, , ))
expect_equal(or3s(ntd <= 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ntd <= 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(nte <= 1L, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(nte <= 1L, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ntf <= 9L, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ntf <= 9L, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ntg <= 0L, w %between% c(-1L, 1L), ),
bor3(ntg <= 0L, w %between% c(-1L, 1L), ))
expect_equal(or3s(nth <= 1L, z %between% c(-1L, 1L), ),
bor3(nth <= 1L, z %between% c(-1L, 1L), ))
expect_equal(or3s(nti <= 9L, v %between% c(-1L, 1L), ),
bor3(nti <= 9L, v %between% c(-1L, 1L), ))
expect_equal(or3s(ntj <= 0L, i %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ntj <= 0L, i %between% c(-1L, 1L), n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ntk <= 1L, t %between% c(-1L, 1L), g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ntk <= 1L, t %between% c(-1L, 1L), g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ntl <= 9L, t %between% c(-1L, 1L), d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ntl <= 9L, t %between% c(-1L, 1L), d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ntm <= 0L, , ),
bor3(ntm <= 0L, , ))
expect_equal(or3s(ntn <= 1L, , ),
bor3(ntn <= 1L, , ))
expect_equal(or3s(nto <= 9L, , ),
bor3(nto <= 9L, , ))
expect_equal(or3s(ntp <= 0L, , q %in% 1:4),
bor3(ntp <= 0L, , q %in% 1:4))
expect_equal(or3s(ntq <= 1L, , f %in% 1:4),
bor3(ntq <= 1L, , f %in% 1:4))
expect_equal(or3s(ntr <= 9L, , m %in% 1:4),
bor3(ntr <= 9L, , m %in% 1:4))
expect_equal(or3s(nts <= 0L, p %between% c(-1L, 1L), ),
bor3(nts <= 0L, p %between% c(-1L, 1L), ))
expect_equal(or3s(ntt <= 1L, p %between% c(-1L, 1L), ),
bor3(ntt <= 1L, p %between% c(-1L, 1L), ))
expect_equal(or3s(ntu <= 9L, c %between% c(-1L, 1L), ),
bor3(ntu <= 9L, c %between% c(-1L, 1L), ))
expect_equal(or3s(ntv <= 0L, y %between% c(-1L, 1L), z %in% 1:4),
bor3(ntv <= 0L, y %between% c(-1L, 1L), z %in% 1:4))
expect_equal(or3s(ntw <= 1L, s %between% c(-1L, 1L), e %in% 1:4),
bor3(ntw <= 1L, s %between% c(-1L, 1L), e %in% 1:4))
expect_equal(or3s(ntx <= 9L, w %between% c(-1L, 1L), g %in% 1:4),
bor3(ntx <= 9L, w %between% c(-1L, 1L), g %in% 1:4))
expect_equal(or3s(nty <= 0L, , ),
bor3(nty <= 0L, , ))
expect_equal(or3s(ntz <= 1L, , ),
bor3(ntz <= 1L, , ))
expect_equal(or3s(nua <= 9L, , ),
bor3(nua <= 9L, , ))
expect_equal(or3s(nub <= 0L, , w < 0L),
bor3(nub <= 0L, , w < 0L))
expect_equal(or3s(nuc <= 1L, , s < 1L),
bor3(nuc <= 1L, , s < 1L))
expect_equal(or3s(nud <= 9L, , i < 9L),
bor3(nud <= 9L, , i < 9L))
expect_equal(or3s(nue <= 0L, p %between% c(-1L, 1L), ),
bor3(nue <= 0L, p %between% c(-1L, 1L), ))
expect_equal(or3s(nuf <= 1L, w %between% c(-1L, 1L), ),
bor3(nuf <= 1L, w %between% c(-1L, 1L), ))
expect_equal(or3s(nug <= 9L, l %between% c(-1L, 1L), ),
bor3(nug <= 9L, l %between% c(-1L, 1L), ))
expect_equal(or3s(nuh <= 0L, r %between% c(-1L, 1L), l < 0L),
bor3(nuh <= 0L, r %between% c(-1L, 1L), l < 0L))
expect_equal(or3s(nui <= 1L, b %between% c(-1L, 1L), o < 1L),
bor3(nui <= 1L, b %between% c(-1L, 1L), o < 1L))
expect_equal(or3s(nuj <= 9L, c %between% c(-1L, 1L), n < 9L),
bor3(nuj <= 9L, c %between% c(-1L, 1L), n < 9L))
expect_equal(or3s(nuk <= 0L, , ),
bor3(nuk <= 0L, , ))
expect_equal(or3s(nul <= 1L, , ),
bor3(nul <= 1L, , ))
expect_equal(or3s(num <= 9L, , ),
bor3(num <= 9L, , ))
expect_equal(or3s(nun <= 0L, , m <= 0L),
bor3(nun <= 0L, , m <= 0L))
expect_equal(or3s(nuo <= 1L, , n <= 1L),
bor3(nuo <= 1L, , n <= 1L))
expect_equal(or3s(nup <= 9L, , a <= 9L),
bor3(nup <= 9L, , a <= 9L))
expect_equal(or3s(nuq <= 0L, i %between% c(-1L, 1L), ),
bor3(nuq <= 0L, i %between% c(-1L, 1L), ))
expect_equal(or3s(nur <= 1L, t %between% c(-1L, 1L), ),
bor3(nur <= 1L, t %between% c(-1L, 1L), ))
expect_equal(or3s(nus <= 9L, j %between% c(-1L, 1L), ),
bor3(nus <= 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(nut <= 0L, o %between% c(-1L, 1L), v <= 0L),
bor3(nut <= 0L, o %between% c(-1L, 1L), v <= 0L))
expect_equal(or3s(nuu <= 1L, a %between% c(-1L, 1L), m <= 1L),
bor3(nuu <= 1L, a %between% c(-1L, 1L), m <= 1L))
expect_equal(or3s(nuv <= 9L, e %between% c(-1L, 1L), f <= 9L),
bor3(nuv <= 9L, e %between% c(-1L, 1L), f <= 9L))
expect_equal(or3s(nuw <= 0L, , ),
bor3(nuw <= 0L, , ))
expect_equal(or3s(nux <= 1L, , ),
bor3(nux <= 1L, , ))
expect_equal(or3s(nuy <= 9L, , ),
bor3(nuy <= 9L, , ))
expect_equal(or3s(nuz <= 0L, , z == 0L),
bor3(nuz <= 0L, , z == 0L))
expect_equal(or3s(nva <= 1L, , u == 1L),
bor3(nva <= 1L, , u == 1L))
expect_equal(or3s(nvb <= 9L, , o == 9L),
bor3(nvb <= 9L, , o == 9L))
expect_equal(or3s(nvc <= 0L, v %between% c(-1L, 1L), ),
bor3(nvc <= 0L, v %between% c(-1L, 1L), ))
expect_equal(or3s(nvd <= 1L, z %between% c(-1L, 1L), ),
bor3(nvd <= 1L, z %between% c(-1L, 1L), ))
expect_equal(or3s(nve <= 9L, v %between% c(-1L, 1L), ),
bor3(nve <= 9L, v %between% c(-1L, 1L), ))
expect_equal(or3s(nvf <= 0L, b %between% c(-1L, 1L), m == 0L),
bor3(nvf <= 0L, b %between% c(-1L, 1L), m == 0L))
expect_equal(or3s(nvg <= 1L, x %between% c(-1L, 1L), x == 1L),
bor3(nvg <= 1L, x %between% c(-1L, 1L), x == 1L))
expect_equal(or3s(nvh <= 9L, u %between% c(-1L, 1L), r == 9L),
bor3(nvh <= 9L, u %between% c(-1L, 1L), r == 9L))
expect_equal(or3s(nvi <= 0L, , ),
bor3(nvi <= 0L, , ))
expect_equal(or3s(nvj <= 1L, , ),
bor3(nvj <= 1L, , ))
expect_equal(or3s(nvk <= 9L, , ),
bor3(nvk <= 9L, , ))
expect_equal(or3s(nvl <= 0L, , w > 0L),
bor3(nvl <= 0L, , w > 0L))
expect_equal(or3s(nvm <= 1L, , l > 1L),
bor3(nvm <= 1L, , l > 1L))
expect_equal(or3s(nvn <= 9L, , j > 9L),
bor3(nvn <= 9L, , j > 9L))
expect_equal(or3s(nvo <= 0L, r %between% c(-1L, 1L), ),
bor3(nvo <= 0L, r %between% c(-1L, 1L), ))
expect_equal(or3s(nvp <= 1L, h %between% c(-1L, 1L), ),
bor3(nvp <= 1L, h %between% c(-1L, 1L), ))
expect_equal(or3s(nvq <= 9L, f %between% c(-1L, 1L), ),
bor3(nvq <= 9L, f %between% c(-1L, 1L), ))
expect_equal(or3s(nvr <= 0L, q %between% c(-1L, 1L), n > 0L),
bor3(nvr <= 0L, q %between% c(-1L, 1L), n > 0L))
expect_equal(or3s(nvs <= 1L, l %between% c(-1L, 1L), g > 1L),
bor3(nvs <= 1L, l %between% c(-1L, 1L), g > 1L))
expect_equal(or3s(nvt <= 9L, v %between% c(-1L, 1L), w > 9L),
bor3(nvt <= 9L, v %between% c(-1L, 1L), w > 9L))
expect_equal(or3s(nvu <= 0L, , ),
bor3(nvu <= 0L, , ))
expect_equal(or3s(nvv <= 1L, , ),
bor3(nvv <= 1L, , ))
expect_equal(or3s(nvw <= 9L, , ),
bor3(nvw <= 9L, , ))
expect_equal(or3s(nvx <= 0L, , w >= 0L),
bor3(nvx <= 0L, , w >= 0L))
expect_equal(or3s(nvy <= 1L, , u >= 1L),
bor3(nvy <= 1L, , u >= 1L))
expect_equal(or3s(nvz <= 9L, , g >= 9L),
bor3(nvz <= 9L, , g >= 9L))
expect_equal(or3s(nwa <= 0L, d %between% c(-1L, 1L), ),
bor3(nwa <= 0L, d %between% c(-1L, 1L), ))
expect_equal(or3s(nwb <= 1L, b %between% c(-1L, 1L), ),
bor3(nwb <= 1L, b %between% c(-1L, 1L), ))
expect_equal(or3s(nwc <= 9L, f %between% c(-1L, 1L), ),
bor3(nwc <= 9L, f %between% c(-1L, 1L), ))
expect_equal(or3s(nwd <= 0L, g %between% c(-1L, 1L), i >= 0L),
bor3(nwd <= 0L, g %between% c(-1L, 1L), i >= 0L))
expect_equal(or3s(nwe <= 1L, x %between% c(-1L, 1L), p >= 1L),
bor3(nwe <= 1L, x %between% c(-1L, 1L), p >= 1L))
expect_equal(or3s(nwf <= 9L, u %between% c(-1L, 1L), s >= 9L),
bor3(nwf <= 9L, u %between% c(-1L, 1L), s >= 9L))
expect_equal(or3s(nwg <= 0L, , ),
bor3(nwg <= 0L, , ))
expect_equal(or3s(nwh <= 1L, , ),
bor3(nwh <= 1L, , ))
expect_equal(or3s(nwi <= 9L, , ),
bor3(nwi <= 9L, , ))
expect_equal(or3s(nwj <= 0L, , logi_n),
bor3(nwj <= 0L, , logi_n))
expect_equal(or3s(nwk <= 1L, , logi_u),
bor3(nwk <= 1L, , logi_u))
expect_equal(or3s(nwl <= 9L, , logi_t),
bor3(nwl <= 9L, , logi_t))
expect_equal(or3s(nwm <= 0L, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nwm <= 0L, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nwn <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nwn <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nwo <= 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nwo <= 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nwp <= 0L, e %in% c(4L, -3L, 2L, 7L, 8L), logi_z),
bor3(nwp <= 0L, e %in% c(4L, -3L, 2L, 7L, 8L), logi_z))
expect_equal(or3s(nwq <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), logi_k),
bor3(nwq <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), logi_k))
expect_equal(or3s(nwr <= 9L, n %in% c(4L, -3L, 2L, 7L, 8L), logi_r),
bor3(nwr <= 9L, n %in% c(4L, -3L, 2L, 7L, 8L), logi_r))
expect_equal(or3s(nws <= 0L, , ),
bor3(nws <= 0L, , ))
expect_equal(or3s(nwt <= 1L, , ),
bor3(nwt <= 1L, , ))
expect_equal(or3s(nwu <= 9L, , ),
bor3(nwu <= 9L, , ))
expect_equal(or3s(nwv <= 0L, , logi_j),
bor3(nwv <= 0L, , logi_j))
expect_equal(or3s(nww <= 1L, , logi_j),
bor3(nww <= 1L, , logi_j))
expect_equal(or3s(nwx <= 9L, , logi_i),
bor3(nwx <= 9L, , logi_i))
expect_equal(or3s(nwy <= 0L, b %in% 1:4, ),
bor3(nwy <= 0L, b %in% 1:4, ))
expect_equal(or3s(nwz <= 1L, x %in% 1:4, ),
bor3(nwz <= 1L, x %in% 1:4, ))
expect_equal(or3s(nxa <= 9L, l %in% 1:4, ),
bor3(nxa <= 9L, l %in% 1:4, ))
expect_equal(or3s(nxb <= 0L, w %in% 1:4, logi_i),
bor3(nxb <= 0L, w %in% 1:4, logi_i))
expect_equal(or3s(nxc <= 1L, x %in% 1:4, logi_b),
bor3(nxc <= 1L, x %in% 1:4, logi_b))
expect_equal(or3s(nxd <= 9L, h %in% 1:4, logi_e),
bor3(nxd <= 9L, h %in% 1:4, logi_e))
expect_equal(or3s(nxe <= 0L, , ),
bor3(nxe <= 0L, , ))
expect_equal(or3s(nxf <= 1L, , ),
bor3(nxf <= 1L, , ))
expect_equal(or3s(nxg <= 9L, , ),
bor3(nxg <= 9L, , ))
expect_equal(or3s(nxh <= 0L, , !logi_l),
bor3(nxh <= 0L, , !logi_l))
expect_equal(or3s(nxi <= 1L, , !logi_k),
bor3(nxi <= 1L, , !logi_k))
expect_equal(or3s(nxj <= 9L, , !logi_y),
bor3(nxj <= 9L, , !logi_y))
expect_equal(or3s(nxk <= 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nxk <= 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nxl <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nxl <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nxm <= 9L, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nxm <= 9L, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nxn <= 0L, d %in% c(4L, -3L, 2L, 7L, 8L), !logi_h),
bor3(nxn <= 0L, d %in% c(4L, -3L, 2L, 7L, 8L), !logi_h))
expect_equal(or3s(nxo <= 1L, y %in% c(4L, -3L, 2L, 7L, 8L), !logi_f),
bor3(nxo <= 1L, y %in% c(4L, -3L, 2L, 7L, 8L), !logi_f))
expect_equal(or3s(nxp <= 9L, p %in% c(4L, -3L, 2L, 7L, 8L), !logi_n),
bor3(nxp <= 9L, p %in% c(4L, -3L, 2L, 7L, 8L), !logi_n))
expect_equal(or3s(nxq <= 0L, , ),
bor3(nxq <= 0L, , ))
expect_equal(or3s(nxr <= 1L, , ),
bor3(nxr <= 1L, , ))
expect_equal(or3s(nxs <= 9L, , ),
bor3(nxs <= 9L, , ))
expect_equal(or3s(nxt <= 0L, , !logi_x),
bor3(nxt <= 0L, , !logi_x))
expect_equal(or3s(nxu <= 1L, , !logi_d),
bor3(nxu <= 1L, , !logi_d))
expect_equal(or3s(nxv <= 9L, , !logi_s),
bor3(nxv <= 9L, , !logi_s))
expect_equal(or3s(nxw <= 0L, t %in% 1:4, ),
bor3(nxw <= 0L, t %in% 1:4, ))
expect_equal(or3s(nxx <= 1L, e %in% 1:4, ),
bor3(nxx <= 1L, e %in% 1:4, ))
expect_equal(or3s(nxy <= 9L, s %in% 1:4, ),
bor3(nxy <= 9L, s %in% 1:4, ))
expect_equal(or3s(nxz <= 0L, i %in% 1:4, !logi_e),
bor3(nxz <= 0L, i %in% 1:4, !logi_e))
expect_equal(or3s(nya <= 1L, e %in% 1:4, !logi_n),
bor3(nya <= 1L, e %in% 1:4, !logi_n))
expect_equal(or3s(nyb <= 9L, z %in% 1:4, !logi_q),
bor3(nyb <= 9L, z %in% 1:4, !logi_q))
expect_equal(or3s(nyc <= 0L, , ),
bor3(nyc <= 0L, , ))
expect_equal(or3s(nyd <= 1L, , ),
bor3(nyd <= 1L, , ))
expect_equal(or3s(nye <= 9L, , ),
bor3(nye <= 9L, , ))
expect_equal(or3s(nyf <= 0L, , y != 0L),
bor3(nyf <= 0L, , y != 0L))
expect_equal(or3s(nyg <= 1L, , m != 1L),
bor3(nyg <= 1L, , m != 1L))
expect_equal(or3s(nyh <= 9L, , v != 9L),
bor3(nyh <= 9L, , v != 9L))
expect_equal(or3s(nyi <= 0L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nyi <= 0L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nyj <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nyj <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nyk <= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(nyk <= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(nyl <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), n != 0L),
bor3(nyl <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), n != 0L))
expect_equal(or3s(nym <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), u != 1L),
bor3(nym <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), u != 1L))
expect_equal(or3s(nyn <= 9L, x %in% c(4L, -3L, 2L, 7L, 8L), o != 9L),
bor3(nyn <= 9L, x %in% c(4L, -3L, 2L, 7L, 8L), o != 9L))
expect_equal(or3s(nyo <= 0L, , ),
bor3(nyo <= 0L, , ))
expect_equal(or3s(nyp <= 1L, , ),
bor3(nyp <= 1L, , ))
expect_equal(or3s(nyq <= 9L, , ),
bor3(nyq <= 9L, , ))
expect_equal(or3s(nyr <= 0L, , w != 0L),
bor3(nyr <= 0L, , w != 0L))
expect_equal(or3s(nys <= 1L, , b != 1L),
bor3(nys <= 1L, , b != 1L))
expect_equal(or3s(nyt <= 9L, , g != 9L),
bor3(nyt <= 9L, , g != 9L))
expect_equal(or3s(nyu <= 0L, f %in% 1:4, ),
bor3(nyu <= 0L, f %in% 1:4, ))
expect_equal(or3s(nyv <= 1L, r %in% 1:4, ),
bor3(nyv <= 1L, r %in% 1:4, ))
expect_equal(or3s(nyw <= 9L, e %in% 1:4, ),
bor3(nyw <= 9L, e %in% 1:4, ))
expect_equal(or3s(nyx <= 0L, b %in% 1:4, i != 0L),
bor3(nyx <= 0L, b %in% 1:4, i != 0L))
expect_equal(or3s(nyy <= 1L, a %in% 1:4, y != 1L),
bor3(nyy <= 1L, a %in% 1:4, y != 1L))
expect_equal(or3s(nyz <= 9L, f %in% 1:4, q != 9L),
bor3(nyz <= 9L, f %in% 1:4, q != 9L))
expect_equal(or3s(oa <= 0L, , ),
bor3(oa <= 0L, , ))
expect_equal(or3s(ob <= 1L, , ),
bor3(ob <= 1L, , ))
expect_equal(or3s(oc <= 9L, , ),
bor3(oc <= 9L, , ))
expect_equal(or3s(od <= 0L, , f %between% c(-1L, 1L)),
bor3(od <= 0L, , f %between% c(-1L, 1L)))
expect_equal(or3s(oe <= 1L, , l %between% c(-1L, 1L)),
bor3(oe <= 1L, , l %between% c(-1L, 1L)))
expect_equal(or3s(of <= 9L, , x %between% c(-1L, 1L)),
bor3(of <= 9L, , x %between% c(-1L, 1L)))
expect_equal(or3s(og <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(og <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oh <= 1L, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oh <= 1L, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oi <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oi <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oj <= 0L, d %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L)),
bor3(oj <= 0L, d %in% c(4L, -3L, 2L, 7L, 8L), t %between% c(-1L, 1L)))
expect_equal(or3s(ok <= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)),
bor3(ok <= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)))
expect_equal(or3s(ol <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L)),
bor3(ol <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), l %between% c(-1L, 1L)))
expect_equal(or3s(om <= 0L, , ),
bor3(om <= 0L, , ))
expect_equal(or3s(on <= 1L, , ),
bor3(on <= 1L, , ))
expect_equal(or3s(oo <= 9L, , ),
bor3(oo <= 9L, , ))
expect_equal(or3s(op <= 0L, , u %between% c(-1L, 1L)),
bor3(op <= 0L, , u %between% c(-1L, 1L)))
expect_equal(or3s(oq <= 1L, , c %between% c(-1L, 1L)),
bor3(oq <= 1L, , c %between% c(-1L, 1L)))
expect_equal(or3s(or <= 9L, , f %between% c(-1L, 1L)),
bor3(or <= 9L, , f %between% c(-1L, 1L)))
expect_equal(or3s(os <= 0L, i %in% 1:4, ),
bor3(os <= 0L, i %in% 1:4, ))
expect_equal(or3s(ot <= 1L, e %in% 1:4, ),
bor3(ot <= 1L, e %in% 1:4, ))
expect_equal(or3s(ou <= 9L, u %in% 1:4, ),
bor3(ou <= 9L, u %in% 1:4, ))
expect_equal(or3s(ov <= 0L, k %in% 1:4, p %between% c(-1L, 1L)),
bor3(ov <= 0L, k %in% 1:4, p %between% c(-1L, 1L)))
expect_equal(or3s(ow <= 1L, x %in% 1:4, s %between% c(-1L, 1L)),
bor3(ow <= 1L, x %in% 1:4, s %between% c(-1L, 1L)))
expect_equal(or3s(ox <= 9L, k %in% 1:4, m %between% c(-1L, 1L)),
bor3(ox <= 9L, k %in% 1:4, m %between% c(-1L, 1L)))
expect_equal(or3s(oy <= 0L, , ),
bor3(oy <= 0L, , ))
expect_equal(or3s(oz <= 1L, , ),
bor3(oz <= 1L, , ))
expect_equal(or3s(oaa <= 9L, , ),
bor3(oaa <= 9L, , ))
expect_equal(or3s(oab <= 0L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oab <= 0L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oac <= 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oac <= 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oad <= 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oad <= 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oae <= 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oae <= 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oaf <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oaf <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oag <= 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oag <= 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oah <= 0L, s %in% c(4L, -3L, 2L, 7L, 8L), r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oah <= 0L, s %in% c(4L, -3L, 2L, 7L, 8L), r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oai <= 1L, c %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oai <= 1L, c %in% c(4L, -3L, 2L, 7L, 8L), u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oaj <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oaj <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L), l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oak <= 0L, , ),
bor3(oak <= 0L, , ))
expect_equal(or3s(oal <= 1L, , ),
bor3(oal <= 1L, , ))
expect_equal(or3s(oam <= 9L, , ),
bor3(oam <= 9L, , ))
expect_equal(or3s(oan <= 0L, , z %in% 1:4),
bor3(oan <= 0L, , z %in% 1:4))
expect_equal(or3s(oao <= 1L, , b %in% 1:4),
bor3(oao <= 1L, , b %in% 1:4))
expect_equal(or3s(oap <= 9L, , a %in% 1:4),
bor3(oap <= 9L, , a %in% 1:4))
expect_equal(or3s(oaq <= 0L, f %in% 1:4, ),
bor3(oaq <= 0L, f %in% 1:4, ))
expect_equal(or3s(oar <= 1L, b %in% 1:4, ),
bor3(oar <= 1L, b %in% 1:4, ))
expect_equal(or3s(oas <= 9L, c %in% 1:4, ),
bor3(oas <= 9L, c %in% 1:4, ))
expect_equal(or3s(oat <= 0L, e %in% 1:4, t %in% 1:4),
bor3(oat <= 0L, e %in% 1:4, t %in% 1:4))
expect_equal(or3s(oau <= 1L, g %in% 1:4, x %in% 1:4),
bor3(oau <= 1L, g %in% 1:4, x %in% 1:4))
expect_equal(or3s(oav <= 9L, t %in% 1:4, h %in% 1:4),
bor3(oav <= 9L, t %in% 1:4, h %in% 1:4))
expect_equal(or3s(oaw <= 0L, , ),
bor3(oaw <= 0L, , ))
expect_equal(or3s(oax <= 1L, , ),
bor3(oax <= 1L, , ))
expect_equal(or3s(oay <= 9L, , ),
bor3(oay <= 9L, , ))
expect_equal(or3s(oaz <= 0L, , d < 0L),
bor3(oaz <= 0L, , d < 0L))
expect_equal(or3s(oba <= 1L, , k < 1L),
bor3(oba <= 1L, , k < 1L))
expect_equal(or3s(obb <= 9L, , q < 9L),
bor3(obb <= 9L, , q < 9L))
expect_equal(or3s(obc <= 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(obc <= 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(obd <= 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(obd <= 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(obe <= 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(obe <= 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(obf <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), n < 0L),
bor3(obf <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), n < 0L))
expect_equal(or3s(obg <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), c < 1L),
bor3(obg <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), c < 1L))
expect_equal(or3s(obh <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), e < 9L),
bor3(obh <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), e < 9L))
expect_equal(or3s(obi <= 0L, , ),
bor3(obi <= 0L, , ))
expect_equal(or3s(obj <= 1L, , ),
bor3(obj <= 1L, , ))
expect_equal(or3s(obk <= 9L, , ),
bor3(obk <= 9L, , ))
expect_equal(or3s(obl <= 0L, , f < 0L),
bor3(obl <= 0L, , f < 0L))
expect_equal(or3s(obm <= 1L, , x < 1L),
bor3(obm <= 1L, , x < 1L))
expect_equal(or3s(obn <= 9L, , y < 9L),
bor3(obn <= 9L, , y < 9L))
expect_equal(or3s(obo <= 0L, l %in% 1:4, ),
bor3(obo <= 0L, l %in% 1:4, ))
expect_equal(or3s(obp <= 1L, n %in% 1:4, ),
bor3(obp <= 1L, n %in% 1:4, ))
expect_equal(or3s(obq <= 9L, j %in% 1:4, ),
bor3(obq <= 9L, j %in% 1:4, ))
expect_equal(or3s(obr <= 0L, e %in% 1:4, c < 0L),
bor3(obr <= 0L, e %in% 1:4, c < 0L))
expect_equal(or3s(obs <= 1L, f %in% 1:4, o < 1L),
bor3(obs <= 1L, f %in% 1:4, o < 1L))
expect_equal(or3s(obt <= 9L, u %in% 1:4, o < 9L),
bor3(obt <= 9L, u %in% 1:4, o < 9L))
expect_equal(or3s(obu <= 0L, , ),
bor3(obu <= 0L, , ))
expect_equal(or3s(obv <= 1L, , ),
bor3(obv <= 1L, , ))
expect_equal(or3s(obw <= 9L, , ),
bor3(obw <= 9L, , ))
expect_equal(or3s(obx <= 0L, , b <= 0L),
bor3(obx <= 0L, , b <= 0L))
expect_equal(or3s(oby <= 1L, , f <= 1L),
bor3(oby <= 1L, , f <= 1L))
expect_equal(or3s(obz <= 9L, , f <= 9L),
bor3(obz <= 9L, , f <= 9L))
expect_equal(or3s(oca <= 0L, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oca <= 0L, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ocb <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ocb <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(occ <= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(occ <= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ocd <= 0L, u %in% c(4L, -3L, 2L, 7L, 8L), p <= 0L),
bor3(ocd <= 0L, u %in% c(4L, -3L, 2L, 7L, 8L), p <= 0L))
expect_equal(or3s(oce <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), y <= 1L),
bor3(oce <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), y <= 1L))
expect_equal(or3s(ocf <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L), w <= 9L),
bor3(ocf <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L), w <= 9L))
expect_equal(or3s(ocg <= 0L, , ),
bor3(ocg <= 0L, , ))
expect_equal(or3s(och <= 1L, , ),
bor3(och <= 1L, , ))
expect_equal(or3s(oci <= 9L, , ),
bor3(oci <= 9L, , ))
expect_equal(or3s(ocj <= 0L, , y <= 0L),
bor3(ocj <= 0L, , y <= 0L))
expect_equal(or3s(ock <= 1L, , d <= 1L),
bor3(ock <= 1L, , d <= 1L))
expect_equal(or3s(ocl <= 9L, , d <= 9L),
bor3(ocl <= 9L, , d <= 9L))
expect_equal(or3s(ocm <= 0L, c %in% 1:4, ),
bor3(ocm <= 0L, c %in% 1:4, ))
expect_equal(or3s(ocn <= 1L, a %in% 1:4, ),
bor3(ocn <= 1L, a %in% 1:4, ))
expect_equal(or3s(oco <= 9L, r %in% 1:4, ),
bor3(oco <= 9L, r %in% 1:4, ))
expect_equal(or3s(ocp <= 0L, p %in% 1:4, i <= 0L),
bor3(ocp <= 0L, p %in% 1:4, i <= 0L))
expect_equal(or3s(ocq <= 1L, t %in% 1:4, u <= 1L),
bor3(ocq <= 1L, t %in% 1:4, u <= 1L))
expect_equal(or3s(ocr <= 9L, k %in% 1:4, t <= 9L),
bor3(ocr <= 9L, k %in% 1:4, t <= 9L))
expect_equal(or3s(ocs <= 0L, , ),
bor3(ocs <= 0L, , ))
expect_equal(or3s(oct <= 1L, , ),
bor3(oct <= 1L, , ))
expect_equal(or3s(ocu <= 9L, , ),
bor3(ocu <= 9L, , ))
expect_equal(or3s(ocv <= 0L, , u == 0L),
bor3(ocv <= 0L, , u == 0L))
expect_equal(or3s(ocw <= 1L, , d == 1L),
bor3(ocw <= 1L, , d == 1L))
expect_equal(or3s(ocx <= 9L, , l == 9L),
bor3(ocx <= 9L, , l == 9L))
expect_equal(or3s(ocy <= 0L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ocy <= 0L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ocz <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ocz <= 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oda <= 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oda <= 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(odb <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), q == 0L),
bor3(odb <= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), q == 0L))
expect_equal(or3s(odc <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), p == 1L),
bor3(odc <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), p == 1L))
expect_equal(or3s(odd <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), t == 9L),
bor3(odd <= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), t == 9L))
expect_equal(or3s(ode <= 0L, , ),
bor3(ode <= 0L, , ))
expect_equal(or3s(odf <= 1L, , ),
bor3(odf <= 1L, , ))
expect_equal(or3s(odg <= 9L, , ),
bor3(odg <= 9L, , ))
expect_equal(or3s(odh <= 0L, , c == 0L),
bor3(odh <= 0L, , c == 0L))
expect_equal(or3s(odi <= 1L, , o == 1L),
bor3(odi <= 1L, , o == 1L))
expect_equal(or3s(odj <= 9L, , z == 9L),
bor3(odj <= 9L, , z == 9L))
expect_equal(or3s(odk <= 0L, n %in% 1:4, ),
bor3(odk <= 0L, n %in% 1:4, ))
expect_equal(or3s(odl <= 1L, j %in% 1:4, ),
bor3(odl <= 1L, j %in% 1:4, ))
expect_equal(or3s(odm <= 9L, j %in% 1:4, ),
bor3(odm <= 9L, j %in% 1:4, ))
expect_equal(or3s(odn <= 0L, e %in% 1:4, c == 0L),
bor3(odn <= 0L, e %in% 1:4, c == 0L))
expect_equal(or3s(odo <= 1L, b %in% 1:4, h == 1L),
bor3(odo <= 1L, b %in% 1:4, h == 1L))
expect_equal(or3s(odp <= 9L, i %in% 1:4, s == 9L),
bor3(odp <= 9L, i %in% 1:4, s == 9L))
expect_equal(or3s(odq <= 0L, , ),
bor3(odq <= 0L, , ))
expect_equal(or3s(odr <= 1L, , ),
bor3(odr <= 1L, , ))
expect_equal(or3s(ods <= 9L, , ),
bor3(ods <= 9L, , ))
expect_equal(or3s(odt <= 0L, , w > 0L),
bor3(odt <= 0L, , w > 0L))
expect_equal(or3s(odu <= 1L, , p > 1L),
bor3(odu <= 1L, , p > 1L))
expect_equal(or3s(odv <= 9L, , c > 9L),
bor3(odv <= 9L, , c > 9L))
expect_equal(or3s(odw <= 0L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(odw <= 0L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(odx <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(odx <= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ody <= 9L, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ody <= 9L, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(odz <= 0L, t %in% c(4L, -3L, 2L, 7L, 8L), v > 0L),
bor3(odz <= 0L, t %in% c(4L, -3L, 2L, 7L, 8L), v > 0L))
expect_equal(or3s(oea <= 1L, r %in% c(4L, -3L, 2L, 7L, 8L), c > 1L),
bor3(oea <= 1L, r %in% c(4L, -3L, 2L, 7L, 8L), c > 1L))
expect_equal(or3s(oeb <= 9L, u %in% c(4L, -3L, 2L, 7L, 8L), y > 9L),
bor3(oeb <= 9L, u %in% c(4L, -3L, 2L, 7L, 8L), y > 9L))
expect_equal(or3s(oec <= 0L, , ),
bor3(oec <= 0L, , ))
expect_equal(or3s(oed <= 1L, , ),
bor3(oed <= 1L, , ))
expect_equal(or3s(oee <= 9L, , ),
bor3(oee <= 9L, , ))
expect_equal(or3s(oef <= 0L, , o > 0L),
bor3(oef <= 0L, , o > 0L))
expect_equal(or3s(oeg <= 1L, , t > 1L),
bor3(oeg <= 1L, , t > 1L))
expect_equal(or3s(oeh <= 9L, , r > 9L),
bor3(oeh <= 9L, , r > 9L))
expect_equal(or3s(oei <= 0L, q %in% 1:4, ),
bor3(oei <= 0L, q %in% 1:4, ))
expect_equal(or3s(oej <= 1L, s %in% 1:4, ),
bor3(oej <= 1L, s %in% 1:4, ))
expect_equal(or3s(oek <= 9L, v %in% 1:4, ),
bor3(oek <= 9L, v %in% 1:4, ))
expect_equal(or3s(oel <= 0L, w %in% 1:4, m > 0L),
bor3(oel <= 0L, w %in% 1:4, m > 0L))
expect_equal(or3s(oem <= 1L, f %in% 1:4, p > 1L),
bor3(oem <= 1L, f %in% 1:4, p > 1L))
expect_equal(or3s(oen <= 9L, g %in% 1:4, x > 9L),
bor3(oen <= 9L, g %in% 1:4, x > 9L))
expect_equal(or3s(oeo <= 0L, , ),
bor3(oeo <= 0L, , ))
expect_equal(or3s(oep <= 1L, , ),
bor3(oep <= 1L, , ))
expect_equal(or3s(oeq <= 9L, , ),
bor3(oeq <= 9L, , ))
expect_equal(or3s(oer <= 0L, , s >= 0L),
bor3(oer <= 0L, , s >= 0L))
expect_equal(or3s(oes <= 1L, , u >= 1L),
bor3(oes <= 1L, , u >= 1L))
expect_equal(or3s(oet <= 9L, , c >= 9L),
bor3(oet <= 9L, , c >= 9L))
expect_equal(or3s(oeu <= 0L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oeu <= 0L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oev <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oev <= 1L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oew <= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(oew <= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(oex <= 0L, z %in% c(4L, -3L, 2L, 7L, 8L), o >= 0L),
bor3(oex <= 0L, z %in% c(4L, -3L, 2L, 7L, 8L), o >= 0L))
expect_equal(or3s(oey <= 1L, x %in% c(4L, -3L, 2L, 7L, 8L), z >= 1L),
bor3(oey <= 1L, x %in% c(4L, -3L, 2L, 7L, 8L), z >= 1L))
expect_equal(or3s(oez <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L),
bor3(oez <= 9L, a %in% c(4L, -3L, 2L, 7L, 8L), x >= 9L))
expect_equal(or3s(ofa <= 0L, , ),
bor3(ofa <= 0L, , ))
expect_equal(or3s(ofb <= 1L, , ),
bor3(ofb <= 1L, , ))
expect_equal(or3s(ofc <= 9L, , ),
bor3(ofc <= 9L, , ))
expect_equal(or3s(ofd <= 0L, , n >= 0L),
bor3(ofd <= 0L, , n >= 0L))
expect_equal(or3s(ofe <= 1L, , h >= 1L),
bor3(ofe <= 1L, , h >= 1L))
expect_equal(or3s(off <= 9L, , m >= 9L),
bor3(off <= 9L, , m >= 9L))
expect_equal(or3s(ofg <= 0L, f %in% 1:4, ),
bor3(ofg <= 0L, f %in% 1:4, ))
expect_equal(or3s(ofh <= 1L, b %in% 1:4, ),
bor3(ofh <= 1L, b %in% 1:4, ))
expect_equal(or3s(ofi <= 9L, a %in% 1:4, ),
bor3(ofi <= 9L, a %in% 1:4, ))
expect_equal(or3s(ofj <= 0L, p %in% 1:4, z >= 0L),
bor3(ofj <= 0L, p %in% 1:4, z >= 0L))
expect_equal(or3s(ofk <= 1L, g %in% 1:4, x >= 1L),
bor3(ofk <= 1L, g %in% 1:4, x >= 1L))
expect_equal(or3s(ofl <= 9L, x %in% 1:4, n >= 9L),
bor3(ofl <= 9L, x %in% 1:4, n >= 9L))
expect_equal(or3s(ofm <= 0L, , ),
bor3(ofm <= 0L, , ))
expect_equal(or3s(ofn <= 1L, , ),
bor3(ofn <= 1L, , ))
expect_equal(or3s(ofo <= 9L, , ),
bor3(ofo <= 9L, , ))
expect_equal(or3s(ofp <= 0L, , logi_x),
bor3(ofp <= 0L, , logi_x))
expect_equal(or3s(ofq <= 1L, , logi_b),
bor3(ofq <= 1L, , logi_b))
expect_equal(or3s(ofr <= 9L, , logi_f),
bor3(ofr <= 9L, , logi_f))
expect_equal(or3s(ofs <= 0L, d < 0L, ),
bor3(ofs <= 0L, d < 0L, ))
expect_equal(or3s(oft <= 1L, g < 1L, ),
bor3(oft <= 1L, g < 1L, ))
expect_equal(or3s(ofu <= 9L, w < 9L, ),
bor3(ofu <= 9L, w < 9L, ))
expect_equal(or3s(ofv <= 0L, a < 0L, logi_v),
bor3(ofv <= 0L, a < 0L, logi_v))
expect_equal(or3s(ofw <= 1L, a < 1L, logi_j),
bor3(ofw <= 1L, a < 1L, logi_j))
expect_equal(or3s(ofx <= 9L, j < 9L, logi_c),
bor3(ofx <= 9L, j < 9L, logi_c))
expect_equal(or3s(ofy <= 0L, , ),
bor3(ofy <= 0L, , ))
expect_equal(or3s(ofz <= 1L, , ),
bor3(ofz <= 1L, , ))
expect_equal(or3s(oga <= 9L, , ),
bor3(oga <= 9L, , ))
expect_equal(or3s(ogb <= 0L, , !logi_n),
bor3(ogb <= 0L, , !logi_n))
expect_equal(or3s(ogc <= 1L, , !logi_i),
bor3(ogc <= 1L, , !logi_i))
expect_equal(or3s(ogd <= 9L, , !logi_v),
bor3(ogd <= 9L, , !logi_v))
expect_equal(or3s(oge <= 0L, t < 0L, ),
bor3(oge <= 0L, t < 0L, ))
expect_equal(or3s(ogf <= 1L, j < 1L, ),
bor3(ogf <= 1L, j < 1L, ))
expect_equal(or3s(ogg <= 9L, z < 9L, ),
bor3(ogg <= 9L, z < 9L, ))
expect_equal(or3s(ogh <= 0L, b < 0L, !logi_r),
bor3(ogh <= 0L, b < 0L, !logi_r))
expect_equal(or3s(ogi <= 1L, m < 1L, !logi_l),
bor3(ogi <= 1L, m < 1L, !logi_l))
expect_equal(or3s(ogj <= 9L, n < 9L, !logi_s),
bor3(ogj <= 9L, n < 9L, !logi_s))
expect_equal(or3s(ogk <= 0L, , ),
bor3(ogk <= 0L, , ))
expect_equal(or3s(ogl <= 1L, , ),
bor3(ogl <= 1L, , ))
expect_equal(or3s(ogm <= 9L, , ),
bor3(ogm <= 9L, , ))
expect_equal(or3s(ogn <= 0L, , w != 0L),
bor3(ogn <= 0L, , w != 0L))
expect_equal(or3s(ogo <= 1L, , c != 1L),
bor3(ogo <= 1L, , c != 1L))
expect_equal(or3s(ogp <= 9L, , c != 9L),
bor3(ogp <= 9L, , c != 9L))
expect_equal(or3s(ogq <= 0L, k < 0L, ),
bor3(ogq <= 0L, k < 0L, ))
expect_equal(or3s(ogr <= 1L, m < 1L, ),
bor3(ogr <= 1L, m < 1L, ))
expect_equal(or3s(ogs <= 9L, a < 9L, ),
bor3(ogs <= 9L, a < 9L, ))
expect_equal(or3s(ogt <= 0L, o < 0L, y != 0L),
bor3(ogt <= 0L, o < 0L, y != 0L))
expect_equal(or3s(ogu <= 1L, a < 1L, u != 1L),
bor3(ogu <= 1L, a < 1L, u != 1L))
expect_equal(or3s(ogv <= 9L, j < 9L, d != 9L),
bor3(ogv <= 9L, j < 9L, d != 9L))
expect_equal(or3s(ogw <= 0L, , ),
bor3(ogw <= 0L, , ))
expect_equal(or3s(ogx <= 1L, , ),
bor3(ogx <= 1L, , ))
expect_equal(or3s(ogy <= 9L, , ),
bor3(ogy <= 9L, , ))
expect_equal(or3s(ogz <= 0L, , d %between% c(-1L, 1L)),
bor3(ogz <= 0L, , d %between% c(-1L, 1L)))
expect_equal(or3s(oha <= 1L, , h %between% c(-1L, 1L)),
bor3(oha <= 1L, , h %between% c(-1L, 1L)))
expect_equal(or3s(ohb <= 9L, , o %between% c(-1L, 1L)),
bor3(ohb <= 9L, , o %between% c(-1L, 1L)))
expect_equal(or3s(ohc <= 0L, w < 0L, ),
bor3(ohc <= 0L, w < 0L, ))
expect_equal(or3s(ohd <= 1L, a < 1L, ),
bor3(ohd <= 1L, a < 1L, ))
expect_equal(or3s(ohe <= 9L, l < 9L, ),
bor3(ohe <= 9L, l < 9L, ))
expect_equal(or3s(ohf <= 0L, z < 0L, k %between% c(-1L, 1L)),
bor3(ohf <= 0L, z < 0L, k %between% c(-1L, 1L)))
expect_equal(or3s(ohg <= 1L, l < 1L, a %between% c(-1L, 1L)),
bor3(ohg <= 1L, l < 1L, a %between% c(-1L, 1L)))
expect_equal(or3s(ohh <= 9L, f < 9L, m %between% c(-1L, 1L)),
bor3(ohh <= 9L, f < 9L, m %between% c(-1L, 1L)))
expect_equal(or3s(ohi <= 0L, , ),
bor3(ohi <= 0L, , ))
expect_equal(or3s(ohj <= 1L, , ),
bor3(ohj <= 1L, , ))
expect_equal(or3s(ohk <= 9L, , ),
bor3(ohk <= 9L, , ))
expect_equal(or3s(ohl <= 0L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ohl <= 0L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ohm <= 1L, , q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ohm <= 1L, , q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ohn <= 9L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ohn <= 9L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oho <= 0L, a < 0L, ),
bor3(oho <= 0L, a < 0L, ))
expect_equal(or3s(ohp <= 1L, g < 1L, ),
bor3(ohp <= 1L, g < 1L, ))
expect_equal(or3s(ohq <= 9L, d < 9L, ),
bor3(ohq <= 9L, d < 9L, ))
expect_equal(or3s(ohr <= 0L, k < 0L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ohr <= 0L, k < 0L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ohs <= 1L, s < 1L, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ohs <= 1L, s < 1L, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oht <= 9L, c < 9L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(oht <= 9L, c < 9L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ohu <= 0L, , ),
bor3(ohu <= 0L, , ))
expect_equal(or3s(ohv <= 1L, , ),
bor3(ohv <= 1L, , ))
expect_equal(or3s(ohw <= 9L, , ),
bor3(ohw <= 9L, , ))
expect_equal(or3s(ohx <= 0L, , d %in% 1:4),
bor3(ohx <= 0L, , d %in% 1:4))
expect_equal(or3s(ohy <= 1L, , c %in% 1:4),
bor3(ohy <= 1L, , c %in% 1:4))
expect_equal(or3s(ohz <= 9L, , q %in% 1:4),
bor3(ohz <= 9L, , q %in% 1:4))
expect_equal(or3s(oia <= 0L, y < 0L, ),
bor3(oia <= 0L, y < 0L, ))
expect_equal(or3s(oib <= 1L, s < 1L, ),
bor3(oib <= 1L, s < 1L, ))
expect_equal(or3s(oic <= 9L, p < 9L, ),
bor3(oic <= 9L, p < 9L, ))
expect_equal(or3s(oid <= 0L, t < 0L, o %in% 1:4),
bor3(oid <= 0L, t < 0L, o %in% 1:4))
expect_equal(or3s(oie <= 1L, m < 1L, f %in% 1:4),
bor3(oie <= 1L, m < 1L, f %in% 1:4))
expect_equal(or3s(oif <= 9L, a < 9L, r %in% 1:4),
bor3(oif <= 9L, a < 9L, r %in% 1:4))
expect_equal(or3s(oig <= 0L, , ),
bor3(oig <= 0L, , ))
expect_equal(or3s(oih <= 1L, , ),
bor3(oih <= 1L, , ))
expect_equal(or3s(oii <= 9L, , ),
bor3(oii <= 9L, , ))
expect_equal(or3s(oij <= 0L, , c < 0L),
bor3(oij <= 0L, , c < 0L))
expect_equal(or3s(oik <= 1L, , i < 1L),
bor3(oik <= 1L, , i < 1L))
expect_equal(or3s(oil <= 9L, , f < 9L),
bor3(oil <= 9L, , f < 9L))
expect_equal(or3s(oim <= 0L, h < 0L, ),
bor3(oim <= 0L, h < 0L, ))
expect_equal(or3s(oin <= 1L, p < 1L, ),
bor3(oin <= 1L, p < 1L, ))
expect_equal(or3s(oio <= 9L, z < 9L, ),
bor3(oio <= 9L, z < 9L, ))
expect_equal(or3s(oip <= 0L, s < 0L, v < 0L),
bor3(oip <= 0L, s < 0L, v < 0L))
expect_equal(or3s(oiq <= 1L, i < 1L, b < 1L),
bor3(oiq <= 1L, i < 1L, b < 1L))
expect_equal(or3s(oir <= 9L, g < 9L, d < 9L),
bor3(oir <= 9L, g < 9L, d < 9L))
expect_equal(or3s(ois <= 0L, , ),
bor3(ois <= 0L, , ))
expect_equal(or3s(oit <= 1L, , ),
bor3(oit <= 1L, , ))
expect_equal(or3s(oiu <= 9L, , ),
bor3(oiu <= 9L, , ))
expect_equal(or3s(oiv <= 0L, , g <= 0L),
bor3(oiv <= 0L, , g <= 0L))
expect_equal(or3s(oiw <= 1L, , n <= 1L),
bor3(oiw <= 1L, , n <= 1L))
expect_equal(or3s(oix <= 9L, , r <= 9L),
bor3(oix <= 9L, , r <= 9L))
expect_equal(or3s(oiy <= 0L, l < 0L, ),
bor3(oiy <= 0L, l < 0L, ))
expect_equal(or3s(oiz <= 1L, h < 1L, ),
bor3(oiz <= 1L, h < 1L, ))
expect_equal(or3s(oja <= 9L, c < 9L, ),
bor3(oja <= 9L, c < 9L, ))
expect_equal(or3s(ojb <= 0L, i < 0L, s <= 0L),
bor3(ojb <= 0L, i < 0L, s <= 0L))
expect_equal(or3s(ojc <= 1L, o < 1L, t <= 1L),
bor3(ojc <= 1L, o < 1L, t <= 1L))
expect_equal(or3s(ojd <= 9L, m < 9L, d <= 9L),
bor3(ojd <= 9L, m < 9L, d <= 9L))
expect_equal(or3s(oje <= 0L, , ),
bor3(oje <= 0L, , ))
expect_equal(or3s(ojf <= 1L, , ),
bor3(ojf <= 1L, , ))
expect_equal(or3s(ojg <= 9L, , ),
bor3(ojg <= 9L, , ))
expect_equal(or3s(ojh <= 0L, , r == 0L),
bor3(ojh <= 0L, , r == 0L))
expect_equal(or3s(oji <= 1L, , z == 1L),
bor3(oji <= 1L, , z == 1L))
expect_equal(or3s(ojj <= 9L, , m == 9L),
bor3(ojj <= 9L, , m == 9L))
expect_equal(or3s(ojk <= 0L, u < 0L, ),
bor3(ojk <= 0L, u < 0L, ))
expect_equal(or3s(ojl <= 1L, y < 1L, ),
bor3(ojl <= 1L, y < 1L, ))
expect_equal(or3s(ojm <= 9L, c < 9L, ),
bor3(ojm <= 9L, c < 9L, ))
expect_equal(or3s(ojn <= 0L, d < 0L, w == 0L),
bor3(ojn <= 0L, d < 0L, w == 0L))
expect_equal(or3s(ojo <= 1L, h < 1L, l == 1L),
bor3(ojo <= 1L, h < 1L, l == 1L))
expect_equal(or3s(ojp <= 9L, y < 9L, w == 9L),
bor3(ojp <= 9L, y < 9L, w == 9L))
expect_equal(or3s(ojq <= 0L, , ),
bor3(ojq <= 0L, , ))
expect_equal(or3s(ojr <= 1L, , ),
bor3(ojr <= 1L, , ))
expect_equal(or3s(ojs <= 9L, , ),
bor3(ojs <= 9L, , ))
expect_equal(or3s(ojt <= 0L, , q > 0L),
bor3(ojt <= 0L, , q > 0L))
expect_equal(or3s(oju <= 1L, , f > 1L),
bor3(oju <= 1L, , f > 1L))
expect_equal(or3s(ojv <= 9L, , b > 9L),
bor3(ojv <= 9L, , b > 9L))
expect_equal(or3s(ojw <= 0L, a < 0L, ),
bor3(ojw <= 0L, a < 0L, ))
expect_equal(or3s(ojx <= 1L, s < 1L, ),
bor3(ojx <= 1L, s < 1L, ))
expect_equal(or3s(ojy <= 9L, a < 9L, ),
bor3(ojy <= 9L, a < 9L, ))
expect_equal(or3s(ojz <= 0L, d < 0L, g > 0L),
bor3(ojz <= 0L, d < 0L, g > 0L))
expect_equal(or3s(oka <= 1L, n < 1L, n > 1L),
bor3(oka <= 1L, n < 1L, n > 1L))
expect_equal(or3s(okb <= 9L, m < 9L, o > 9L),
bor3(okb <= 9L, m < 9L, o > 9L))
expect_equal(or3s(okc <= 0L, , ),
bor3(okc <= 0L, , ))
expect_equal(or3s(okd <= 1L, , ),
bor3(okd <= 1L, , ))
expect_equal(or3s(oke <= 9L, , ),
bor3(oke <= 9L, , ))
expect_equal(or3s(okf <= 0L, , d >= 0L),
bor3(okf <= 0L, , d >= 0L))
expect_equal(or3s(okg <= 1L, , a >= 1L),
bor3(okg <= 1L, , a >= 1L))
expect_equal(or3s(okh <= 9L, , u >= 9L),
bor3(okh <= 9L, , u >= 9L))
expect_equal(or3s(oki <= 0L, k < 0L, ),
bor3(oki <= 0L, k < 0L, ))
expect_equal(or3s(okj <= 1L, t < 1L, ),
bor3(okj <= 1L, t < 1L, ))
expect_equal(or3s(okk <= 9L, l < 9L, ),
bor3(okk <= 9L, l < 9L, ))
expect_equal(or3s(okl <= 0L, a < 0L, a >= 0L),
bor3(okl <= 0L, a < 0L, a >= 0L))
expect_equal(or3s(okm <= 1L, k < 1L, j >= 1L),
bor3(okm <= 1L, k < 1L, j >= 1L))
expect_equal(or3s(okn <= 9L, l < 9L, v >= 9L),
bor3(okn <= 9L, l < 9L, v >= 9L))
expect_equal(or3s(oko <= 0L, , ),
bor3(oko <= 0L, , ))
expect_equal(or3s(okp <= 1L, , ),
bor3(okp <= 1L, , ))
expect_equal(or3s(okq <= 9L, , ),
bor3(okq <= 9L, , ))
expect_equal(or3s(okr <= 0L, , logi_p),
bor3(okr <= 0L, , logi_p))
expect_equal(or3s(oks <= 1L, , logi_o),
bor3(oks <= 1L, , logi_o))
expect_equal(or3s(okt <= 9L, , logi_f),
bor3(okt <= 9L, , logi_f))
expect_equal(or3s(oku <= 0L, u <= 0L, ),
bor3(oku <= 0L, u <= 0L, ))
expect_equal(or3s(okv <= 1L, v <= 1L, ),
bor3(okv <= 1L, v <= 1L, ))
expect_equal(or3s(okw <= 9L, t <= 9L, ),
bor3(okw <= 9L, t <= 9L, ))
expect_equal(or3s(okx <= 0L, s <= 0L, logi_g),
bor3(okx <= 0L, s <= 0L, logi_g))
expect_equal(or3s(oky <= 1L, p <= 1L, logi_d),
bor3(oky <= 1L, p <= 1L, logi_d))
expect_equal(or3s(okz <= 9L, s <= 9L, logi_g),
bor3(okz <= 9L, s <= 9L, logi_g))
expect_equal(or3s(ola <= 0L, , ),
bor3(ola <= 0L, , ))
expect_equal(or3s(olb <= 1L, , ),
bor3(olb <= 1L, , ))
expect_equal(or3s(olc <= 9L, , ),
bor3(olc <= 9L, , ))
expect_equal(or3s(old <= 0L, , !logi_d),
bor3(old <= 0L, , !logi_d))
expect_equal(or3s(ole <= 1L, , !logi_a),
bor3(ole <= 1L, , !logi_a))
expect_equal(or3s(olf <= 9L, , !logi_q),
bor3(olf <= 9L, , !logi_q))
expect_equal(or3s(olg <= 0L, v <= 0L, ),
bor3(olg <= 0L, v <= 0L, ))
expect_equal(or3s(olh <= 1L, f <= 1L, ),
bor3(olh <= 1L, f <= 1L, ))
expect_equal(or3s(oli <= 9L, z <= 9L, ),
bor3(oli <= 9L, z <= 9L, ))
expect_equal(or3s(olj <= 0L, u <= 0L, !logi_q),
bor3(olj <= 0L, u <= 0L, !logi_q))
expect_equal(or3s(olk <= 1L, l <= 1L, !logi_h),
bor3(olk <= 1L, l <= 1L, !logi_h))
expect_equal(or3s(oll <= 9L, c <= 9L, !logi_l),
bor3(oll <= 9L, c <= 9L, !logi_l))
expect_equal(or3s(olm <= 0L, , ),
bor3(olm <= 0L, , ))
expect_equal(or3s(oln <= 1L, , ),
bor3(oln <= 1L, , ))
expect_equal(or3s(olo <= 9L, , ),
bor3(olo <= 9L, , ))
expect_equal(or3s(olp <= 0L, , i != 0L),
bor3(olp <= 0L, , i != 0L))
expect_equal(or3s(olq <= 1L, , n != 1L),
bor3(olq <= 1L, , n != 1L))
expect_equal(or3s(olr <= 9L, , z != 9L),
bor3(olr <= 9L, , z != 9L))
expect_equal(or3s(ols <= 0L, g <= 0L, ),
bor3(ols <= 0L, g <= 0L, ))
expect_equal(or3s(olt <= 1L, v <= 1L, ),
bor3(olt <= 1L, v <= 1L, ))
expect_equal(or3s(olu <= 9L, v <= 9L, ),
bor3(olu <= 9L, v <= 9L, ))
expect_equal(or3s(olv <= 0L, m <= 0L, z != 0L),
bor3(olv <= 0L, m <= 0L, z != 0L))
expect_equal(or3s(olw <= 1L, j <= 1L, y != 1L),
bor3(olw <= 1L, j <= 1L, y != 1L))
expect_equal(or3s(olx <= 9L, s <= 9L, g != 9L),
bor3(olx <= 9L, s <= 9L, g != 9L))
expect_equal(or3s(oly <= 0L, , ),
bor3(oly <= 0L, , ))
expect_equal(or3s(olz <= 1L, , ),
bor3(olz <= 1L, , ))
expect_equal(or3s(oma <= 9L, , ),
bor3(oma <= 9L, , ))
expect_equal(or3s(omb <= 0L, , k %between% c(-1L, 1L)),
bor3(omb <= 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(omc <= 1L, , a %between% c(-1L, 1L)),
bor3(omc <= 1L, , a %between% c(-1L, 1L)))
expect_equal(or3s(omd <= 9L, , q %between% c(-1L, 1L)),
bor3(omd <= 9L, , q %between% c(-1L, 1L)))
expect_equal(or3s(ome <= 0L, j <= 0L, ),
bor3(ome <= 0L, j <= 0L, ))
expect_equal(or3s(omf <= 1L, s <= 1L, ),
bor3(omf <= 1L, s <= 1L, ))
expect_equal(or3s(omg <= 9L, i <= 9L, ),
bor3(omg <= 9L, i <= 9L, ))
expect_equal(or3s(omh <= 0L, f <= 0L, w %between% c(-1L, 1L)),
bor3(omh <= 0L, f <= 0L, w %between% c(-1L, 1L)))
expect_equal(or3s(omi <= 1L, s <= 1L, h %between% c(-1L, 1L)),
bor3(omi <= 1L, s <= 1L, h %between% c(-1L, 1L)))
expect_equal(or3s(omj <= 9L, o <= 9L, q %between% c(-1L, 1L)),
bor3(omj <= 9L, o <= 9L, q %between% c(-1L, 1L)))
expect_equal(or3s(omk <= 0L, , ),
bor3(omk <= 0L, , ))
expect_equal(or3s(oml <= 1L, , ),
bor3(oml <= 1L, , ))
expect_equal(or3s(omm <= 9L, , ),
bor3(omm <= 9L, , ))
expect_equal(or3s(omn <= 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(omn <= 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(omo <= 1L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(omo <= 1L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(omp <= 9L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(omp <= 9L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(omq <= 0L, p <= 0L, ),
bor3(omq <= 0L, p <= 0L, ))
expect_equal(or3s(omr <= 1L, c <= 1L, ),
bor3(omr <= 1L, c <= 1L, ))
expect_equal(or3s(oms <= 9L, n <= 9L, ),
bor3(oms <= 9L, n <= 9L, ))
expect_equal(or3s(omt <= 0L, e <= 0L, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(omt <= 0L, e <= 0L, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(omu <= 1L, a <= 1L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(omu <= 1L, a <= 1L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(omv <= 9L, c <= 9L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(omv <= 9L, c <= 9L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(omw <= 0L, , ),
bor3(omw <= 0L, , ))
expect_equal(or3s(omx <= 1L, , ),
bor3(omx <= 1L, , ))
expect_equal(or3s(omy <= 9L, , ),
bor3(omy <= 9L, , ))
expect_equal(or3s(omz <= 0L, , x %in% 1:4),
bor3(omz <= 0L, , x %in% 1:4))
expect_equal(or3s(ona <= 1L, , e %in% 1:4),
bor3(ona <= 1L, , e %in% 1:4))
expect_equal(or3s(onb <= 9L, , f %in% 1:4),
bor3(onb <= 9L, , f %in% 1:4))
expect_equal(or3s(onc <= 0L, w <= 0L, ),
bor3(onc <= 0L, w <= 0L, ))
expect_equal(or3s(ond <= 1L, i <= 1L, ),
bor3(ond <= 1L, i <= 1L, ))
expect_equal(or3s(one <= 9L, d <= 9L, ),
bor3(one <= 9L, d <= 9L, ))
expect_equal(or3s(onf <= 0L, k <= 0L, y %in% 1:4),
bor3(onf <= 0L, k <= 0L, y %in% 1:4))
expect_equal(or3s(ong <= 1L, l <= 1L, p %in% 1:4),
bor3(ong <= 1L, l <= 1L, p %in% 1:4))
expect_equal(or3s(onh <= 9L, u <= 9L, w %in% 1:4),
bor3(onh <= 9L, u <= 9L, w %in% 1:4))
expect_equal(or3s(oni <= 0L, , ),
bor3(oni <= 0L, , ))
expect_equal(or3s(onj <= 1L, , ),
bor3(onj <= 1L, , ))
expect_equal(or3s(onk <= 9L, , ),
bor3(onk <= 9L, , ))
expect_equal(or3s(onl <= 0L, , r < 0L),
bor3(onl <= 0L, , r < 0L))
expect_equal(or3s(onm <= 1L, , m < 1L),
bor3(onm <= 1L, , m < 1L))
expect_equal(or3s(onn <= 9L, , o < 9L),
bor3(onn <= 9L, , o < 9L))
expect_equal(or3s(ono <= 0L, d <= 0L, ),
bor3(ono <= 0L, d <= 0L, ))
expect_equal(or3s(onp <= 1L, x <= 1L, ),
bor3(onp <= 1L, x <= 1L, ))
expect_equal(or3s(onq <= 9L, l <= 9L, ),
bor3(onq <= 9L, l <= 9L, ))
expect_equal(or3s(onr <= 0L, l <= 0L, u < 0L),
bor3(onr <= 0L, l <= 0L, u < 0L))
expect_equal(or3s(ons <= 1L, v <= 1L, s < 1L),
bor3(ons <= 1L, v <= 1L, s < 1L))
expect_equal(or3s(ont <= 9L, v <= 9L, i < 9L),
bor3(ont <= 9L, v <= 9L, i < 9L))
expect_equal(or3s(onu <= 0L, , ),
bor3(onu <= 0L, , ))
expect_equal(or3s(onv <= 1L, , ),
bor3(onv <= 1L, , ))
expect_equal(or3s(onw <= 9L, , ),
bor3(onw <= 9L, , ))
expect_equal(or3s(onx <= 0L, , p <= 0L),
bor3(onx <= 0L, , p <= 0L))
expect_equal(or3s(ony <= 1L, , e <= 1L),
bor3(ony <= 1L, , e <= 1L))
expect_equal(or3s(onz <= 9L, , v <= 9L),
bor3(onz <= 9L, , v <= 9L))
expect_equal(or3s(ooa <= 0L, u <= 0L, ),
bor3(ooa <= 0L, u <= 0L, ))
expect_equal(or3s(oob <= 1L, f <= 1L, ),
bor3(oob <= 1L, f <= 1L, ))
expect_equal(or3s(ooc <= 9L, l <= 9L, ),
bor3(ooc <= 9L, l <= 9L, ))
expect_equal(or3s(ood <= 0L, t <= 0L, y <= 0L),
bor3(ood <= 0L, t <= 0L, y <= 0L))
expect_equal(or3s(ooe <= 1L, y <= 1L, f <= 1L),
bor3(ooe <= 1L, y <= 1L, f <= 1L))
expect_equal(or3s(oof <= 9L, n <= 9L, f <= 9L),
bor3(oof <= 9L, n <= 9L, f <= 9L))
expect_equal(or3s(oog <= 0L, , ),
bor3(oog <= 0L, , ))
expect_equal(or3s(ooh <= 1L, , ),
bor3(ooh <= 1L, , ))
expect_equal(or3s(ooi <= 9L, , ),
bor3(ooi <= 9L, , ))
expect_equal(or3s(ooj <= 0L, , o == 0L),
bor3(ooj <= 0L, , o == 0L))
expect_equal(or3s(ook <= 1L, , s == 1L),
bor3(ook <= 1L, , s == 1L))
expect_equal(or3s(ool <= 9L, , n == 9L),
bor3(ool <= 9L, , n == 9L))
expect_equal(or3s(oom <= 0L, u <= 0L, ),
bor3(oom <= 0L, u <= 0L, ))
expect_equal(or3s(oon <= 1L, l <= 1L, ),
bor3(oon <= 1L, l <= 1L, ))
expect_equal(or3s(ooo <= 9L, u <= 9L, ),
bor3(ooo <= 9L, u <= 9L, ))
expect_equal(or3s(oop <= 0L, g <= 0L, o == 0L),
bor3(oop <= 0L, g <= 0L, o == 0L))
expect_equal(or3s(ooq <= 1L, v <= 1L, z == 1L),
bor3(ooq <= 1L, v <= 1L, z == 1L))
expect_equal(or3s(oor <= 9L, v <= 9L, s == 9L),
bor3(oor <= 9L, v <= 9L, s == 9L))
expect_equal(or3s(oos <= 0L, , ),
bor3(oos <= 0L, , ))
expect_equal(or3s(oot <= 1L, , ),
bor3(oot <= 1L, , ))
expect_equal(or3s(oou <= 9L, , ),
bor3(oou <= 9L, , ))
expect_equal(or3s(oov <= 0L, , k > 0L),
bor3(oov <= 0L, , k > 0L))
expect_equal(or3s(oow <= 1L, , u > 1L),
bor3(oow <= 1L, , u > 1L))
expect_equal(or3s(oox <= 9L, , f > 9L),
bor3(oox <= 9L, , f > 9L))
expect_equal(or3s(ooy <= 0L, l <= 0L, ),
bor3(ooy <= 0L, l <= 0L, ))
expect_equal(or3s(ooz <= 1L, f <= 1L, ),
bor3(ooz <= 1L, f <= 1L, ))
expect_equal(or3s(opa <= 9L, t <= 9L, ),
bor3(opa <= 9L, t <= 9L, ))
expect_equal(or3s(opb <= 0L, u <= 0L, d > 0L),
bor3(opb <= 0L, u <= 0L, d > 0L))
expect_equal(or3s(opc <= 1L, m <= 1L, b > 1L),
bor3(opc <= 1L, m <= 1L, b > 1L))
expect_equal(or3s(opd <= 9L, o <= 9L, m > 9L),
bor3(opd <= 9L, o <= 9L, m > 9L))
expect_equal(or3s(ope <= 0L, , ),
bor3(ope <= 0L, , ))
expect_equal(or3s(opf <= 1L, , ),
bor3(opf <= 1L, , ))
expect_equal(or3s(opg <= 9L, , ),
bor3(opg <= 9L, , ))
expect_equal(or3s(oph <= 0L, , f >= 0L),
bor3(oph <= 0L, , f >= 0L))
expect_equal(or3s(opi <= 1L, , p >= 1L),
bor3(opi <= 1L, , p >= 1L))
expect_equal(or3s(opj <= 9L, , z >= 9L),
bor3(opj <= 9L, , z >= 9L))
expect_equal(or3s(opk <= 0L, z <= 0L, ),
bor3(opk <= 0L, z <= 0L, ))
expect_equal(or3s(opl <= 1L, b <= 1L, ),
bor3(opl <= 1L, b <= 1L, ))
expect_equal(or3s(opm <= 9L, a <= 9L, ),
bor3(opm <= 9L, a <= 9L, ))
expect_equal(or3s(opn <= 0L, o <= 0L, m >= 0L),
bor3(opn <= 0L, o <= 0L, m >= 0L))
expect_equal(or3s(opo <= 1L, j <= 1L, z >= 1L),
bor3(opo <= 1L, j <= 1L, z >= 1L))
expect_equal(or3s(opp <= 9L, g <= 9L, a >= 9L),
bor3(opp <= 9L, g <= 9L, a >= 9L))
expect_equal(or3s(opq <= 0L, , ),
bor3(opq <= 0L, , ))
expect_equal(or3s(opr <= 1L, , ),
bor3(opr <= 1L, , ))
expect_equal(or3s(ops <= 9L, , ),
bor3(ops <= 9L, , ))
expect_equal(or3s(opt <= 0L, , logi_b),
bor3(opt <= 0L, , logi_b))
expect_equal(or3s(opu <= 1L, , logi_d),
bor3(opu <= 1L, , logi_d))
expect_equal(or3s(opv <= 9L, , logi_g),
bor3(opv <= 9L, , logi_g))
expect_equal(or3s(opw <= 0L, u == 0L, ),
bor3(opw <= 0L, u == 0L, ))
expect_equal(or3s(opx <= 1L, b == 1L, ),
bor3(opx <= 1L, b == 1L, ))
expect_equal(or3s(opy <= 9L, p == 9L, ),
bor3(opy <= 9L, p == 9L, ))
expect_equal(or3s(opz <= 0L, n == 0L, logi_y),
bor3(opz <= 0L, n == 0L, logi_y))
expect_equal(or3s(oqa <= 1L, z == 1L, logi_z),
bor3(oqa <= 1L, z == 1L, logi_z))
expect_equal(or3s(oqb <= 9L, l == 9L, logi_h),
bor3(oqb <= 9L, l == 9L, logi_h))
expect_equal(or3s(oqc <= 0L, , ),
bor3(oqc <= 0L, , ))
expect_equal(or3s(oqd <= 1L, , ),
bor3(oqd <= 1L, , ))
expect_equal(or3s(oqe <= 9L, , ),
bor3(oqe <= 9L, , ))
expect_equal(or3s(oqf <= 0L, , !logi_m),
bor3(oqf <= 0L, , !logi_m))
expect_equal(or3s(oqg <= 1L, , !logi_b),
bor3(oqg <= 1L, , !logi_b))
expect_equal(or3s(oqh <= 9L, , !logi_u),
bor3(oqh <= 9L, , !logi_u))
expect_equal(or3s(oqi <= 0L, x == 0L, ),
bor3(oqi <= 0L, x == 0L, ))
expect_equal(or3s(oqj <= 1L, x == 1L, ),
bor3(oqj <= 1L, x == 1L, ))
expect_equal(or3s(oqk <= 9L, b == 9L, ),
bor3(oqk <= 9L, b == 9L, ))
expect_equal(or3s(oql <= 0L, z == 0L, !logi_n),
bor3(oql <= 0L, z == 0L, !logi_n))
expect_equal(or3s(oqm <= 1L, f == 1L, !logi_y),
bor3(oqm <= 1L, f == 1L, !logi_y))
expect_equal(or3s(oqn <= 9L, o == 9L, !logi_c),
bor3(oqn <= 9L, o == 9L, !logi_c))
expect_equal(or3s(oqo <= 0L, , ),
bor3(oqo <= 0L, , ))
expect_equal(or3s(oqp <= 1L, , ),
bor3(oqp <= 1L, , ))
expect_equal(or3s(oqq <= 9L, , ),
bor3(oqq <= 9L, , ))
expect_equal(or3s(oqr <= 0L, , s != 0L),
bor3(oqr <= 0L, , s != 0L))
expect_equal(or3s(oqs <= 1L, , y != 1L),
bor3(oqs <= 1L, , y != 1L))
expect_equal(or3s(oqt <= 9L, , n != 9L),
bor3(oqt <= 9L, , n != 9L))
expect_equal(or3s(oqu <= 0L, h == 0L, ),
bor3(oqu <= 0L, h == 0L, ))
expect_equal(or3s(oqv <= 1L, t == 1L, ),
bor3(oqv <= 1L, t == 1L, ))
expect_equal(or3s(oqw <= 9L, i == 9L, ),
bor3(oqw <= 9L, i == 9L, ))
expect_equal(or3s(oqx <= 0L, h == 0L, h != 0L),
bor3(oqx <= 0L, h == 0L, h != 0L))
expect_equal(or3s(oqy <= 1L, r == 1L, d != 1L),
bor3(oqy <= 1L, r == 1L, d != 1L))
expect_equal(or3s(oqz <= 9L, q == 9L, s != 9L),
bor3(oqz <= 9L, q == 9L, s != 9L))
expect_equal(or3s(ora <= 0L, , ),
bor3(ora <= 0L, , ))
expect_equal(or3s(orb <= 1L, , ),
bor3(orb <= 1L, , ))
expect_equal(or3s(orc <= 9L, , ),
bor3(orc <= 9L, , ))
expect_equal(or3s(ord <= 0L, , g %between% c(-1L, 1L)),
bor3(ord <= 0L, , g %between% c(-1L, 1L)))
expect_equal(or3s(ore <= 1L, , z %between% c(-1L, 1L)),
bor3(ore <= 1L, , z %between% c(-1L, 1L)))
expect_equal(or3s(orf <= 9L, , r %between% c(-1L, 1L)),
bor3(orf <= 9L, , r %between% c(-1L, 1L)))
expect_equal(or3s(org <= 0L, v == 0L, ),
bor3(org <= 0L, v == 0L, ))
expect_equal(or3s(orh <= 1L, w == 1L, ),
bor3(orh <= 1L, w == 1L, ))
expect_equal(or3s(ori <= 9L, b == 9L, ),
bor3(ori <= 9L, b == 9L, ))
expect_equal(or3s(orj <= 0L, l == 0L, x %between% c(-1L, 1L)),
bor3(orj <= 0L, l == 0L, x %between% c(-1L, 1L)))
expect_equal(or3s(ork <= 1L, g == 1L, t %between% c(-1L, 1L)),
bor3(ork <= 1L, g == 1L, t %between% c(-1L, 1L)))
expect_equal(or3s(orl <= 9L, c == 9L, o %between% c(-1L, 1L)),
bor3(orl <= 9L, c == 9L, o %between% c(-1L, 1L)))
expect_equal(or3s(orm <= 0L, , ),
bor3(orm <= 0L, , ))
expect_equal(or3s(orn <= 1L, , ),
bor3(orn <= 1L, , ))
expect_equal(or3s(oro <= 9L, , ),
bor3(oro <= 9L, , ))
expect_equal(or3s(orp <= 0L, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(orp <= 0L, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(orq <= 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(orq <= 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(orr <= 9L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(orr <= 9L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ors <= 0L, i == 0L, ),
bor3(ors <= 0L, i == 0L, ))
expect_equal(or3s(ort <= 1L, c == 1L, ),
bor3(ort <= 1L, c == 1L, ))
expect_equal(or3s(oru <= 9L, y == 9L, ),
bor3(oru <= 9L, y == 9L, ))
expect_equal(or3s(orv <= 0L, y == 0L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(orv <= 0L, y == 0L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(orw <= 1L, e == 1L, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(orw <= 1L, e == 1L, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(orx <= 9L, p == 9L, m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(orx <= 9L, p == 9L, m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ory <= 0L, , ),
bor3(ory <= 0L, , ))
expect_equal(or3s(orz <= 1L, , ),
bor3(orz <= 1L, , ))
expect_equal(or3s(osa <= 9L, , ),
bor3(osa <= 9L, , ))
expect_equal(or3s(osb <= 0L, , h %in% 1:4),
bor3(osb <= 0L, , h %in% 1:4))
expect_equal(or3s(osc <= 1L, , q %in% 1:4),
bor3(osc <= 1L, , q %in% 1:4))
expect_equal(or3s(osd <= 9L, , s %in% 1:4),
bor3(osd <= 9L, , s %in% 1:4))
expect_equal(or3s(ose <= 0L, m == 0L, ),
bor3(ose <= 0L, m == 0L, ))
expect_equal(or3s(osf <= 1L, w == 1L, ),
bor3(osf <= 1L, w == 1L, ))
expect_equal(or3s(osg <= 9L, k == 9L, ),
bor3(osg <= 9L, k == 9L, ))
expect_equal(or3s(osh <= 0L, y == 0L, p %in% 1:4),
bor3(osh <= 0L, y == 0L, p %in% 1:4))
expect_equal(or3s(osi <= 1L, v == 1L, m %in% 1:4),
bor3(osi <= 1L, v == 1L, m %in% 1:4))
expect_equal(or3s(osj <= 9L, y == 9L, o %in% 1:4),
bor3(osj <= 9L, y == 9L, o %in% 1:4))
expect_equal(or3s(osk <= 0L, , ),
bor3(osk <= 0L, , ))
expect_equal(or3s(osl <= 1L, , ),
bor3(osl <= 1L, , ))
expect_equal(or3s(osm <= 9L, , ),
bor3(osm <= 9L, , ))
expect_equal(or3s(osn <= 0L, , f < 0L),
bor3(osn <= 0L, , f < 0L))
expect_equal(or3s(oso <= 1L, , q < 1L),
bor3(oso <= 1L, , q < 1L))
expect_equal(or3s(osp <= 9L, , p < 9L),
bor3(osp <= 9L, , p < 9L))
expect_equal(or3s(osq <= 0L, u == 0L, ),
bor3(osq <= 0L, u == 0L, ))
expect_equal(or3s(osr <= 1L, a == 1L, ),
bor3(osr <= 1L, a == 1L, ))
expect_equal(or3s(oss <= 9L, z == 9L, ),
bor3(oss <= 9L, z == 9L, ))
expect_equal(or3s(ost <= 0L, e == 0L, o < 0L),
bor3(ost <= 0L, e == 0L, o < 0L))
expect_equal(or3s(osu <= 1L, x == 1L, q < 1L),
bor3(osu <= 1L, x == 1L, q < 1L))
expect_equal(or3s(osv <= 9L, r == 9L, x < 9L),
bor3(osv <= 9L, r == 9L, x < 9L))
expect_equal(or3s(osw <= 0L, , ),
bor3(osw <= 0L, , ))
expect_equal(or3s(osx <= 1L, , ),
bor3(osx <= 1L, , ))
expect_equal(or3s(osy <= 9L, , ),
bor3(osy <= 9L, , ))
expect_equal(or3s(osz <= 0L, , e <= 0L),
bor3(osz <= 0L, , e <= 0L))
expect_equal(or3s(ota <= 1L, , z <= 1L),
bor3(ota <= 1L, , z <= 1L))
expect_equal(or3s(otb <= 9L, , i <= 9L),
bor3(otb <= 9L, , i <= 9L))
expect_equal(or3s(otc <= 0L, i == 0L, ),
bor3(otc <= 0L, i == 0L, ))
expect_equal(or3s(otd <= 1L, u == 1L, ),
bor3(otd <= 1L, u == 1L, ))
expect_equal(or3s(ote <= 9L, z == 9L, ),
bor3(ote <= 9L, z == 9L, ))
expect_equal(or3s(otf <= 0L, u == 0L, f <= 0L),
bor3(otf <= 0L, u == 0L, f <= 0L))
expect_equal(or3s(otg <= 1L, c == 1L, x <= 1L),
bor3(otg <= 1L, c == 1L, x <= 1L))
expect_equal(or3s(oth <= 9L, y == 9L, h <= 9L),
bor3(oth <= 9L, y == 9L, h <= 9L))
expect_equal(or3s(oti <= 0L, , ),
bor3(oti <= 0L, , ))
expect_equal(or3s(otj <= 1L, , ),
bor3(otj <= 1L, , ))
expect_equal(or3s(otk <= 9L, , ),
bor3(otk <= 9L, , ))
expect_equal(or3s(otl <= 0L, , o == 0L),
bor3(otl <= 0L, , o == 0L))
expect_equal(or3s(otm <= 1L, , k == 1L),
bor3(otm <= 1L, , k == 1L))
expect_equal(or3s(otn <= 9L, , e == 9L),
bor3(otn <= 9L, , e == 9L))
expect_equal(or3s(oto <= 0L, p == 0L, ),
bor3(oto <= 0L, p == 0L, ))
expect_equal(or3s(otp <= 1L, w == 1L, ),
bor3(otp <= 1L, w == 1L, ))
expect_equal(or3s(otq <= 9L, m == 9L, ),
bor3(otq <= 9L, m == 9L, ))
expect_equal(or3s(otr <= 0L, n == 0L, u == 0L),
bor3(otr <= 0L, n == 0L, u == 0L))
expect_equal(or3s(ots <= 1L, k == 1L, r == 1L),
bor3(ots <= 1L, k == 1L, r == 1L))
expect_equal(or3s(ott <= 9L, d == 9L, e == 9L),
bor3(ott <= 9L, d == 9L, e == 9L))
expect_equal(or3s(otu <= 0L, , ),
bor3(otu <= 0L, , ))
expect_equal(or3s(otv <= 1L, , ),
bor3(otv <= 1L, , ))
expect_equal(or3s(otw <= 9L, , ),
bor3(otw <= 9L, , ))
expect_equal(or3s(otx <= 0L, , b > 0L),
bor3(otx <= 0L, , b > 0L))
expect_equal(or3s(oty <= 1L, , p > 1L),
bor3(oty <= 1L, , p > 1L))
expect_equal(or3s(otz <= 9L, , d > 9L),
bor3(otz <= 9L, , d > 9L))
expect_equal(or3s(oua <= 0L, m == 0L, ),
bor3(oua <= 0L, m == 0L, ))
expect_equal(or3s(oub <= 1L, h == 1L, ),
bor3(oub <= 1L, h == 1L, ))
expect_equal(or3s(ouc <= 9L, e == 9L, ),
bor3(ouc <= 9L, e == 9L, ))
expect_equal(or3s(oud <= 0L, p == 0L, p > 0L),
bor3(oud <= 0L, p == 0L, p > 0L))
expect_equal(or3s(oue <= 1L, y == 1L, w > 1L),
bor3(oue <= 1L, y == 1L, w > 1L))
expect_equal(or3s(ouf <= 9L, d == 9L, m > 9L),
bor3(ouf <= 9L, d == 9L, m > 9L))
expect_equal(or3s(oug <= 0L, , ),
bor3(oug <= 0L, , ))
expect_equal(or3s(ouh <= 1L, , ),
bor3(ouh <= 1L, , ))
expect_equal(or3s(oui <= 9L, , ),
bor3(oui <= 9L, , ))
expect_equal(or3s(ouj <= 0L, , s >= 0L),
bor3(ouj <= 0L, , s >= 0L))
expect_equal(or3s(ouk <= 1L, , m >= 1L),
bor3(ouk <= 1L, , m >= 1L))
expect_equal(or3s(oul <= 9L, , a >= 9L),
bor3(oul <= 9L, , a >= 9L))
expect_equal(or3s(oum <= 0L, l == 0L, ),
bor3(oum <= 0L, l == 0L, ))
expect_equal(or3s(oun <= 1L, s == 1L, ),
bor3(oun <= 1L, s == 1L, ))
expect_equal(or3s(ouo <= 9L, v == 9L, ),
bor3(ouo <= 9L, v == 9L, ))
expect_equal(or3s(oup <= 0L, n == 0L, w >= 0L),
bor3(oup <= 0L, n == 0L, w >= 0L))
expect_equal(or3s(ouq <= 1L, f == 1L, f >= 1L),
bor3(ouq <= 1L, f == 1L, f >= 1L))
expect_equal(or3s(our <= 9L, g == 9L, j >= 9L),
bor3(our <= 9L, g == 9L, j >= 9L))
expect_equal(or3s(ous <= 0L, , ),
bor3(ous <= 0L, , ))
expect_equal(or3s(out <= 1L, , ),
bor3(out <= 1L, , ))
expect_equal(or3s(ouu <= 9L, , ),
bor3(ouu <= 9L, , ))
expect_equal(or3s(ouv <= 0L, , logi_n),
bor3(ouv <= 0L, , logi_n))
expect_equal(or3s(ouw <= 1L, , logi_l),
bor3(ouw <= 1L, , logi_l))
expect_equal(or3s(oux <= 9L, , logi_d),
bor3(oux <= 9L, , logi_d))
expect_equal(or3s(ouy <= 0L, g > 0L, ),
bor3(ouy <= 0L, g > 0L, ))
expect_equal(or3s(ouz <= 1L, f > 1L, ),
bor3(ouz <= 1L, f > 1L, ))
expect_equal(or3s(ova <= 9L, g > 9L, ),
bor3(ova <= 9L, g > 9L, ))
expect_equal(or3s(ovb <= 0L, j > 0L, logi_p),
bor3(ovb <= 0L, j > 0L, logi_p))
expect_equal(or3s(ovc <= 1L, p > 1L, logi_w),
bor3(ovc <= 1L, p > 1L, logi_w))
expect_equal(or3s(ovd <= 9L, b > 9L, logi_x),
bor3(ovd <= 9L, b > 9L, logi_x))
expect_equal(or3s(ove <= 0L, , ),
bor3(ove <= 0L, , ))
expect_equal(or3s(ovf <= 1L, , ),
bor3(ovf <= 1L, , ))
expect_equal(or3s(ovg <= 9L, , ),
bor3(ovg <= 9L, , ))
expect_equal(or3s(ovh <= 0L, , !logi_n),
bor3(ovh <= 0L, , !logi_n))
expect_equal(or3s(ovi <= 1L, , !logi_v),
bor3(ovi <= 1L, , !logi_v))
expect_equal(or3s(ovj <= 9L, , !logi_q),
bor3(ovj <= 9L, , !logi_q))
expect_equal(or3s(ovk <= 0L, c > 0L, ),
bor3(ovk <= 0L, c > 0L, ))
expect_equal(or3s(ovl <= 1L, e > 1L, ),
bor3(ovl <= 1L, e > 1L, ))
expect_equal(or3s(ovm <= 9L, g > 9L, ),
bor3(ovm <= 9L, g > 9L, ))
expect_equal(or3s(ovn <= 0L, x > 0L, !logi_s),
bor3(ovn <= 0L, x > 0L, !logi_s))
expect_equal(or3s(ovo <= 1L, w > 1L, !logi_u),
bor3(ovo <= 1L, w > 1L, !logi_u))
expect_equal(or3s(ovp <= 9L, j > 9L, !logi_h),
bor3(ovp <= 9L, j > 9L, !logi_h))
expect_equal(or3s(ovq <= 0L, , ),
bor3(ovq <= 0L, , ))
expect_equal(or3s(ovr <= 1L, , ),
bor3(ovr <= 1L, , ))
expect_equal(or3s(ovs <= 9L, , ),
bor3(ovs <= 9L, , ))
expect_equal(or3s(ovt <= 0L, , u != 0L),
bor3(ovt <= 0L, , u != 0L))
expect_equal(or3s(ovu <= 1L, , g != 1L),
bor3(ovu <= 1L, , g != 1L))
expect_equal(or3s(ovv <= 9L, , e != 9L),
bor3(ovv <= 9L, , e != 9L))
expect_equal(or3s(ovw <= 0L, r > 0L, ),
bor3(ovw <= 0L, r > 0L, ))
expect_equal(or3s(ovx <= 1L, k > 1L, ),
bor3(ovx <= 1L, k > 1L, ))
expect_equal(or3s(ovy <= 9L, s > 9L, ),
bor3(ovy <= 9L, s > 9L, ))
expect_equal(or3s(ovz <= 0L, d > 0L, i != 0L),
bor3(ovz <= 0L, d > 0L, i != 0L))
expect_equal(or3s(owa <= 1L, f > 1L, k != 1L),
bor3(owa <= 1L, f > 1L, k != 1L))
expect_equal(or3s(owb <= 9L, g > 9L, w != 9L),
bor3(owb <= 9L, g > 9L, w != 9L))
expect_equal(or3s(owc <= 0L, , ),
bor3(owc <= 0L, , ))
expect_equal(or3s(owd <= 1L, , ),
bor3(owd <= 1L, , ))
expect_equal(or3s(owe <= 9L, , ),
bor3(owe <= 9L, , ))
expect_equal(or3s(owf <= 0L, , o %between% c(-1L, 1L)),
bor3(owf <= 0L, , o %between% c(-1L, 1L)))
expect_equal(or3s(owg <= 1L, , n %between% c(-1L, 1L)),
bor3(owg <= 1L, , n %between% c(-1L, 1L)))
expect_equal(or3s(owh <= 9L, , y %between% c(-1L, 1L)),
bor3(owh <= 9L, , y %between% c(-1L, 1L)))
expect_equal(or3s(owi <= 0L, z > 0L, ),
bor3(owi <= 0L, z > 0L, ))
expect_equal(or3s(owj <= 1L, f > 1L, ),
bor3(owj <= 1L, f > 1L, ))
expect_equal(or3s(owk <= 9L, e > 9L, ),
bor3(owk <= 9L, e > 9L, ))
expect_equal(or3s(owl <= 0L, n > 0L, v %between% c(-1L, 1L)),
bor3(owl <= 0L, n > 0L, v %between% c(-1L, 1L)))
expect_equal(or3s(owm <= 1L, o > 1L, a %between% c(-1L, 1L)),
bor3(owm <= 1L, o > 1L, a %between% c(-1L, 1L)))
expect_equal(or3s(own <= 9L, e > 9L, i %between% c(-1L, 1L)),
bor3(own <= 9L, e > 9L, i %between% c(-1L, 1L)))
expect_equal(or3s(owo <= 0L, , ),
bor3(owo <= 0L, , ))
expect_equal(or3s(owp <= 1L, , ),
bor3(owp <= 1L, , ))
expect_equal(or3s(owq <= 9L, , ),
bor3(owq <= 9L, , ))
expect_equal(or3s(owr <= 0L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(owr <= 0L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ows <= 1L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ows <= 1L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(owt <= 9L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(owt <= 9L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(owu <= 0L, d > 0L, ),
bor3(owu <= 0L, d > 0L, ))
expect_equal(or3s(owv <= 1L, d > 1L, ),
bor3(owv <= 1L, d > 1L, ))
expect_equal(or3s(oww <= 9L, e > 9L, ),
bor3(oww <= 9L, e > 9L, ))
expect_equal(or3s(owx <= 0L, l > 0L, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(owx <= 0L, l > 0L, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(owy <= 1L, b > 1L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(owy <= 1L, b > 1L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(owz <= 9L, u > 9L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(owz <= 9L, u > 9L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(oxa <= 0L, , ),
bor3(oxa <= 0L, , ))
expect_equal(or3s(oxb <= 1L, , ),
bor3(oxb <= 1L, , ))
expect_equal(or3s(oxc <= 9L, , ),
bor3(oxc <= 9L, , ))
expect_equal(or3s(oxd <= 0L, , h %in% 1:4),
bor3(oxd <= 0L, , h %in% 1:4))
expect_equal(or3s(oxe <= 1L, , r %in% 1:4),
bor3(oxe <= 1L, , r %in% 1:4))
expect_equal(or3s(oxf <= 9L, , s %in% 1:4),
bor3(oxf <= 9L, , s %in% 1:4))
expect_equal(or3s(oxg <= 0L, m > 0L, ),
bor3(oxg <= 0L, m > 0L, ))
expect_equal(or3s(oxh <= 1L, r > 1L, ),
bor3(oxh <= 1L, r > 1L, ))
expect_equal(or3s(oxi <= 9L, t > 9L, ),
bor3(oxi <= 9L, t > 9L, ))
expect_equal(or3s(oxj <= 0L, p > 0L, j %in% 1:4),
bor3(oxj <= 0L, p > 0L, j %in% 1:4))
expect_equal(or3s(oxk <= 1L, i > 1L, l %in% 1:4),
bor3(oxk <= 1L, i > 1L, l %in% 1:4))
expect_equal(or3s(oxl <= 9L, f > 9L, k %in% 1:4),
bor3(oxl <= 9L, f > 9L, k %in% 1:4))
expect_equal(or3s(oxm <= 0L, , ),
bor3(oxm <= 0L, , ))
expect_equal(or3s(oxn <= 1L, , ),
bor3(oxn <= 1L, , ))
expect_equal(or3s(oxo <= 9L, , ),
bor3(oxo <= 9L, , ))
expect_equal(or3s(oxp <= 0L, , y < 0L),
bor3(oxp <= 0L, , y < 0L))
expect_equal(or3s(oxq <= 1L, , t < 1L),
bor3(oxq <= 1L, , t < 1L))
expect_equal(or3s(oxr <= 9L, , o < 9L),
bor3(oxr <= 9L, , o < 9L))
expect_equal(or3s(oxs <= 0L, k > 0L, ),
bor3(oxs <= 0L, k > 0L, ))
expect_equal(or3s(oxt <= 1L, e > 1L, ),
bor3(oxt <= 1L, e > 1L, ))
expect_equal(or3s(oxu <= 9L, c > 9L, ),
bor3(oxu <= 9L, c > 9L, ))
expect_equal(or3s(oxv <= 0L, f > 0L, j < 0L),
bor3(oxv <= 0L, f > 0L, j < 0L))
expect_equal(or3s(oxw <= 1L, z > 1L, a < 1L),
bor3(oxw <= 1L, z > 1L, a < 1L))
expect_equal(or3s(oxx <= 9L, i > 9L, q < 9L),
bor3(oxx <= 9L, i > 9L, q < 9L))
expect_equal(or3s(oxy <= 0L, , ),
bor3(oxy <= 0L, , ))
expect_equal(or3s(oxz <= 1L, , ),
bor3(oxz <= 1L, , ))
expect_equal(or3s(oya <= 9L, , ),
bor3(oya <= 9L, , ))
expect_equal(or3s(oyb <= 0L, , n <= 0L),
bor3(oyb <= 0L, , n <= 0L))
expect_equal(or3s(oyc <= 1L, , c <= 1L),
bor3(oyc <= 1L, , c <= 1L))
expect_equal(or3s(oyd <= 9L, , n <= 9L),
bor3(oyd <= 9L, , n <= 9L))
expect_equal(or3s(oye <= 0L, o > 0L, ),
bor3(oye <= 0L, o > 0L, ))
expect_equal(or3s(oyf <= 1L, f > 1L, ),
bor3(oyf <= 1L, f > 1L, ))
expect_equal(or3s(oyg <= 9L, m > 9L, ),
bor3(oyg <= 9L, m > 9L, ))
expect_equal(or3s(oyh <= 0L, h > 0L, j <= 0L),
bor3(oyh <= 0L, h > 0L, j <= 0L))
expect_equal(or3s(oyi <= 1L, i > 1L, o <= 1L),
bor3(oyi <= 1L, i > 1L, o <= 1L))
expect_equal(or3s(oyj <= 9L, u > 9L, d <= 9L),
bor3(oyj <= 9L, u > 9L, d <= 9L))
expect_equal(or3s(oyk <= 0L, , ),
bor3(oyk <= 0L, , ))
expect_equal(or3s(oyl <= 1L, , ),
bor3(oyl <= 1L, , ))
expect_equal(or3s(oym <= 9L, , ),
bor3(oym <= 9L, , ))
expect_equal(or3s(oyn <= 0L, , m == 0L),
bor3(oyn <= 0L, , m == 0L))
expect_equal(or3s(oyo <= 1L, , j == 1L),
bor3(oyo <= 1L, , j == 1L))
expect_equal(or3s(oyp <= 9L, , q == 9L),
bor3(oyp <= 9L, , q == 9L))
expect_equal(or3s(oyq <= 0L, k > 0L, ),
bor3(oyq <= 0L, k > 0L, ))
expect_equal(or3s(oyr <= 1L, j > 1L, ),
bor3(oyr <= 1L, j > 1L, ))
expect_equal(or3s(oys <= 9L, h > 9L, ),
bor3(oys <= 9L, h > 9L, ))
expect_equal(or3s(oyt <= 0L, x > 0L, w == 0L),
bor3(oyt <= 0L, x > 0L, w == 0L))
expect_equal(or3s(oyu <= 1L, v > 1L, u == 1L),
bor3(oyu <= 1L, v > 1L, u == 1L))
expect_equal(or3s(oyv <= 9L, t > 9L, p == 9L),
bor3(oyv <= 9L, t > 9L, p == 9L))
expect_equal(or3s(oyw <= 0L, , ),
bor3(oyw <= 0L, , ))
expect_equal(or3s(oyx <= 1L, , ),
bor3(oyx <= 1L, , ))
expect_equal(or3s(oyy <= 9L, , ),
bor3(oyy <= 9L, , ))
expect_equal(or3s(oyz <= 0L, , m > 0L),
bor3(oyz <= 0L, , m > 0L))
expect_equal(or3s(pa <= 1L, , h > 1L),
bor3(pa <= 1L, , h > 1L))
expect_equal(or3s(pb <= 9L, , u > 9L),
bor3(pb <= 9L, , u > 9L))
expect_equal(or3s(pc <= 0L, o > 0L, ),
bor3(pc <= 0L, o > 0L, ))
expect_equal(or3s(pd <= 1L, c > 1L, ),
bor3(pd <= 1L, c > 1L, ))
expect_equal(or3s(pe <= 9L, a > 9L, ),
bor3(pe <= 9L, a > 9L, ))
expect_equal(or3s(pf <= 0L, c > 0L, q > 0L),
bor3(pf <= 0L, c > 0L, q > 0L))
expect_equal(or3s(pg <= 1L, q > 1L, u > 1L),
bor3(pg <= 1L, q > 1L, u > 1L))
expect_equal(or3s(ph <= 9L, o > 9L, m > 9L),
bor3(ph <= 9L, o > 9L, m > 9L))
expect_equal(or3s(pi <= 0L, , ),
bor3(pi <= 0L, , ))
expect_equal(or3s(pj <= 1L, , ),
bor3(pj <= 1L, , ))
expect_equal(or3s(pk <= 9L, , ),
bor3(pk <= 9L, , ))
expect_equal(or3s(pl <= 0L, , s >= 0L),
bor3(pl <= 0L, , s >= 0L))
expect_equal(or3s(pm <= 1L, , s >= 1L),
bor3(pm <= 1L, , s >= 1L))
expect_equal(or3s(pn <= 9L, , m >= 9L),
bor3(pn <= 9L, , m >= 9L))
expect_equal(or3s(po <= 0L, w > 0L, ),
bor3(po <= 0L, w > 0L, ))
expect_equal(or3s(pp <= 1L, l > 1L, ),
bor3(pp <= 1L, l > 1L, ))
expect_equal(or3s(pq <= 9L, q > 9L, ),
bor3(pq <= 9L, q > 9L, ))
expect_equal(or3s(pr <= 0L, w > 0L, u >= 0L),
bor3(pr <= 0L, w > 0L, u >= 0L))
expect_equal(or3s(ps <= 1L, t > 1L, b >= 1L),
bor3(ps <= 1L, t > 1L, b >= 1L))
expect_equal(or3s(pt <= 9L, z > 9L, o >= 9L),
bor3(pt <= 9L, z > 9L, o >= 9L))
expect_equal(or3s(pu <= 0L, , ),
bor3(pu <= 0L, , ))
expect_equal(or3s(pv <= 1L, , ),
bor3(pv <= 1L, , ))
expect_equal(or3s(pw <= 9L, , ),
bor3(pw <= 9L, , ))
expect_equal(or3s(px <= 0L, , logi_c),
bor3(px <= 0L, , logi_c))
expect_equal(or3s(py <= 1L, , logi_v),
bor3(py <= 1L, , logi_v))
expect_equal(or3s(pz <= 9L, , logi_m),
bor3(pz <= 9L, , logi_m))
expect_equal(or3s(paa <= 0L, a >= 0L, ),
bor3(paa <= 0L, a >= 0L, ))
expect_equal(or3s(pab <= 1L, y >= 1L, ),
bor3(pab <= 1L, y >= 1L, ))
expect_equal(or3s(pac <= 9L, c >= 9L, ),
bor3(pac <= 9L, c >= 9L, ))
expect_equal(or3s(pad <= 0L, y >= 0L, logi_w),
bor3(pad <= 0L, y >= 0L, logi_w))
expect_equal(or3s(pae <= 1L, u >= 1L, logi_x),
bor3(pae <= 1L, u >= 1L, logi_x))
expect_equal(or3s(paf <= 9L, t >= 9L, logi_u),
bor3(paf <= 9L, t >= 9L, logi_u))
expect_equal(or3s(pag <= 0L, , ),
bor3(pag <= 0L, , ))
expect_equal(or3s(pah <= 1L, , ),
bor3(pah <= 1L, , ))
expect_equal(or3s(pai <= 9L, , ),
bor3(pai <= 9L, , ))
expect_equal(or3s(paj <= 0L, , !logi_c),
bor3(paj <= 0L, , !logi_c))
expect_equal(or3s(pak <= 1L, , !logi_t),
bor3(pak <= 1L, , !logi_t))
expect_equal(or3s(pal <= 9L, , !logi_t),
bor3(pal <= 9L, , !logi_t))
expect_equal(or3s(pam <= 0L, h >= 0L, ),
bor3(pam <= 0L, h >= 0L, ))
expect_equal(or3s(pan <= 1L, h >= 1L, ),
bor3(pan <= 1L, h >= 1L, ))
expect_equal(or3s(pao <= 9L, r >= 9L, ),
bor3(pao <= 9L, r >= 9L, ))
expect_equal(or3s(pap <= 0L, t >= 0L, !logi_g),
bor3(pap <= 0L, t >= 0L, !logi_g))
expect_equal(or3s(paq <= 1L, u >= 1L, !logi_v),
bor3(paq <= 1L, u >= 1L, !logi_v))
expect_equal(or3s(par <= 9L, a >= 9L, !logi_n),
bor3(par <= 9L, a >= 9L, !logi_n))
expect_equal(or3s(pas <= 0L, , ),
bor3(pas <= 0L, , ))
expect_equal(or3s(pat <= 1L, , ),
bor3(pat <= 1L, , ))
expect_equal(or3s(pau <= 9L, , ),
bor3(pau <= 9L, , ))
expect_equal(or3s(pav <= 0L, , l != 0L),
bor3(pav <= 0L, , l != 0L))
expect_equal(or3s(paw <= 1L, , z != 1L),
bor3(paw <= 1L, , z != 1L))
expect_equal(or3s(pax <= 9L, , s != 9L),
bor3(pax <= 9L, , s != 9L))
expect_equal(or3s(pay <= 0L, u >= 0L, ),
bor3(pay <= 0L, u >= 0L, ))
expect_equal(or3s(paz <= 1L, c >= 1L, ),
bor3(paz <= 1L, c >= 1L, ))
expect_equal(or3s(pba <= 9L, x >= 9L, ),
bor3(pba <= 9L, x >= 9L, ))
expect_equal(or3s(pbb <= 0L, u >= 0L, c != 0L),
bor3(pbb <= 0L, u >= 0L, c != 0L))
expect_equal(or3s(pbc <= 1L, t >= 1L, t != 1L),
bor3(pbc <= 1L, t >= 1L, t != 1L))
expect_equal(or3s(pbd <= 9L, v >= 9L, e != 9L),
bor3(pbd <= 9L, v >= 9L, e != 9L))
expect_equal(or3s(pbe <= 0L, , ),
bor3(pbe <= 0L, , ))
expect_equal(or3s(pbf <= 1L, , ),
bor3(pbf <= 1L, , ))
expect_equal(or3s(pbg <= 9L, , ),
bor3(pbg <= 9L, , ))
expect_equal(or3s(pbh <= 0L, , z %between% c(-1L, 1L)),
bor3(pbh <= 0L, , z %between% c(-1L, 1L)))
expect_equal(or3s(pbi <= 1L, , z %between% c(-1L, 1L)),
bor3(pbi <= 1L, , z %between% c(-1L, 1L)))
expect_equal(or3s(pbj <= 9L, , c %between% c(-1L, 1L)),
bor3(pbj <= 9L, , c %between% c(-1L, 1L)))
expect_equal(or3s(pbk <= 0L, e >= 0L, ),
bor3(pbk <= 0L, e >= 0L, ))
expect_equal(or3s(pbl <= 1L, b >= 1L, ),
bor3(pbl <= 1L, b >= 1L, ))
expect_equal(or3s(pbm <= 9L, m >= 9L, ),
bor3(pbm <= 9L, m >= 9L, ))
expect_equal(or3s(pbn <= 0L, q >= 0L, m %between% c(-1L, 1L)),
bor3(pbn <= 0L, q >= 0L, m %between% c(-1L, 1L)))
expect_equal(or3s(pbo <= 1L, b >= 1L, x %between% c(-1L, 1L)),
bor3(pbo <= 1L, b >= 1L, x %between% c(-1L, 1L)))
expect_equal(or3s(pbp <= 9L, e >= 9L, y %between% c(-1L, 1L)),
bor3(pbp <= 9L, e >= 9L, y %between% c(-1L, 1L)))
expect_equal(or3s(pbq <= 0L, , ),
bor3(pbq <= 0L, , ))
expect_equal(or3s(pbr <= 1L, , ),
bor3(pbr <= 1L, , ))
expect_equal(or3s(pbs <= 9L, , ),
bor3(pbs <= 9L, , ))
expect_equal(or3s(pbt <= 0L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pbt <= 0L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pbu <= 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pbu <= 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pbv <= 9L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pbv <= 9L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pbw <= 0L, g >= 0L, ),
bor3(pbw <= 0L, g >= 0L, ))
expect_equal(or3s(pbx <= 1L, b >= 1L, ),
bor3(pbx <= 1L, b >= 1L, ))
expect_equal(or3s(pby <= 9L, m >= 9L, ),
bor3(pby <= 9L, m >= 9L, ))
expect_equal(or3s(pbz <= 0L, u >= 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pbz <= 0L, u >= 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pca <= 1L, i >= 1L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pca <= 1L, i >= 1L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pcb <= 9L, r >= 9L, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pcb <= 9L, r >= 9L, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pcc <= 0L, , ),
bor3(pcc <= 0L, , ))
expect_equal(or3s(pcd <= 1L, , ),
bor3(pcd <= 1L, , ))
expect_equal(or3s(pce <= 9L, , ),
bor3(pce <= 9L, , ))
expect_equal(or3s(pcf <= 0L, , x %in% 1:4),
bor3(pcf <= 0L, , x %in% 1:4))
expect_equal(or3s(pcg <= 1L, , r %in% 1:4),
bor3(pcg <= 1L, , r %in% 1:4))
expect_equal(or3s(pch <= 9L, , m %in% 1:4),
bor3(pch <= 9L, , m %in% 1:4))
expect_equal(or3s(pci <= 0L, w >= 0L, ),
bor3(pci <= 0L, w >= 0L, ))
expect_equal(or3s(pcj <= 1L, w >= 1L, ),
bor3(pcj <= 1L, w >= 1L, ))
expect_equal(or3s(pck <= 9L, y >= 9L, ),
bor3(pck <= 9L, y >= 9L, ))
expect_equal(or3s(pcl <= 0L, l >= 0L, k %in% 1:4),
bor3(pcl <= 0L, l >= 0L, k %in% 1:4))
expect_equal(or3s(pcm <= 1L, c >= 1L, w %in% 1:4),
bor3(pcm <= 1L, c >= 1L, w %in% 1:4))
expect_equal(or3s(pcn <= 9L, u >= 9L, h %in% 1:4),
bor3(pcn <= 9L, u >= 9L, h %in% 1:4))
expect_equal(or3s(pco <= 0L, , ),
bor3(pco <= 0L, , ))
expect_equal(or3s(pcp <= 1L, , ),
bor3(pcp <= 1L, , ))
expect_equal(or3s(pcq <= 9L, , ),
bor3(pcq <= 9L, , ))
expect_equal(or3s(pcr <= 0L, , o < 0L),
bor3(pcr <= 0L, , o < 0L))
expect_equal(or3s(pcs <= 1L, , s < 1L),
bor3(pcs <= 1L, , s < 1L))
expect_equal(or3s(pct <= 9L, , m < 9L),
bor3(pct <= 9L, , m < 9L))
expect_equal(or3s(pcu <= 0L, r >= 0L, ),
bor3(pcu <= 0L, r >= 0L, ))
expect_equal(or3s(pcv <= 1L, s >= 1L, ),
bor3(pcv <= 1L, s >= 1L, ))
expect_equal(or3s(pcw <= 9L, q >= 9L, ),
bor3(pcw <= 9L, q >= 9L, ))
expect_equal(or3s(pcx <= 0L, l >= 0L, h < 0L),
bor3(pcx <= 0L, l >= 0L, h < 0L))
expect_equal(or3s(pcy <= 1L, k >= 1L, k < 1L),
bor3(pcy <= 1L, k >= 1L, k < 1L))
expect_equal(or3s(pcz <= 9L, b >= 9L, n < 9L),
bor3(pcz <= 9L, b >= 9L, n < 9L))
expect_equal(or3s(pda <= 0L, , ),
bor3(pda <= 0L, , ))
expect_equal(or3s(pdb <= 1L, , ),
bor3(pdb <= 1L, , ))
expect_equal(or3s(pdc <= 9L, , ),
bor3(pdc <= 9L, , ))
expect_equal(or3s(pdd <= 0L, , l <= 0L),
bor3(pdd <= 0L, , l <= 0L))
expect_equal(or3s(pde <= 1L, , b <= 1L),
bor3(pde <= 1L, , b <= 1L))
expect_equal(or3s(pdf <= 9L, , c <= 9L),
bor3(pdf <= 9L, , c <= 9L))
expect_equal(or3s(pdg <= 0L, z >= 0L, ),
bor3(pdg <= 0L, z >= 0L, ))
expect_equal(or3s(pdh <= 1L, o >= 1L, ),
bor3(pdh <= 1L, o >= 1L, ))
expect_equal(or3s(pdi <= 9L, t >= 9L, ),
bor3(pdi <= 9L, t >= 9L, ))
expect_equal(or3s(pdj <= 0L, h >= 0L, r <= 0L),
bor3(pdj <= 0L, h >= 0L, r <= 0L))
expect_equal(or3s(pdk <= 1L, y >= 1L, q <= 1L),
bor3(pdk <= 1L, y >= 1L, q <= 1L))
expect_equal(or3s(pdl <= 9L, j >= 9L, a <= 9L),
bor3(pdl <= 9L, j >= 9L, a <= 9L))
expect_equal(or3s(pdm <= 0L, , ),
bor3(pdm <= 0L, , ))
expect_equal(or3s(pdn <= 1L, , ),
bor3(pdn <= 1L, , ))
expect_equal(or3s(pdo <= 9L, , ),
bor3(pdo <= 9L, , ))
expect_equal(or3s(pdp <= 0L, , a == 0L),
bor3(pdp <= 0L, , a == 0L))
expect_equal(or3s(pdq <= 1L, , y == 1L),
bor3(pdq <= 1L, , y == 1L))
expect_equal(or3s(pdr <= 9L, , p == 9L),
bor3(pdr <= 9L, , p == 9L))
expect_equal(or3s(pds <= 0L, s >= 0L, ),
bor3(pds <= 0L, s >= 0L, ))
expect_equal(or3s(pdt <= 1L, h >= 1L, ),
bor3(pdt <= 1L, h >= 1L, ))
expect_equal(or3s(pdu <= 9L, c >= 9L, ),
bor3(pdu <= 9L, c >= 9L, ))
expect_equal(or3s(pdv <= 0L, v >= 0L, p == 0L),
bor3(pdv <= 0L, v >= 0L, p == 0L))
expect_equal(or3s(pdw <= 1L, g >= 1L, v == 1L),
bor3(pdw <= 1L, g >= 1L, v == 1L))
expect_equal(or3s(pdx <= 9L, s >= 9L, u == 9L),
bor3(pdx <= 9L, s >= 9L, u == 9L))
expect_equal(or3s(pdy <= 0L, , ),
bor3(pdy <= 0L, , ))
expect_equal(or3s(pdz <= 1L, , ),
bor3(pdz <= 1L, , ))
expect_equal(or3s(pea <= 9L, , ),
bor3(pea <= 9L, , ))
expect_equal(or3s(peb <= 0L, , x > 0L),
bor3(peb <= 0L, , x > 0L))
expect_equal(or3s(pec <= 1L, , n > 1L),
bor3(pec <= 1L, , n > 1L))
expect_equal(or3s(ped <= 9L, , h > 9L),
bor3(ped <= 9L, , h > 9L))
expect_equal(or3s(pee <= 0L, a >= 0L, ),
bor3(pee <= 0L, a >= 0L, ))
expect_equal(or3s(pef <= 1L, j >= 1L, ),
bor3(pef <= 1L, j >= 1L, ))
expect_equal(or3s(peg <= 9L, d >= 9L, ),
bor3(peg <= 9L, d >= 9L, ))
expect_equal(or3s(peh <= 0L, z >= 0L, u > 0L),
bor3(peh <= 0L, z >= 0L, u > 0L))
expect_equal(or3s(pei <= 1L, g >= 1L, e > 1L),
bor3(pei <= 1L, g >= 1L, e > 1L))
expect_equal(or3s(pej <= 9L, v >= 9L, t > 9L),
bor3(pej <= 9L, v >= 9L, t > 9L))
expect_equal(or3s(pek <= 0L, , ),
bor3(pek <= 0L, , ))
expect_equal(or3s(pel <= 1L, , ),
bor3(pel <= 1L, , ))
expect_equal(or3s(pem <= 9L, , ),
bor3(pem <= 9L, , ))
expect_equal(or3s(pen <= 0L, , u >= 0L),
bor3(pen <= 0L, , u >= 0L))
expect_equal(or3s(peo <= 1L, , i >= 1L),
bor3(peo <= 1L, , i >= 1L))
expect_equal(or3s(pep <= 9L, , j >= 9L),
bor3(pep <= 9L, , j >= 9L))
expect_equal(or3s(peq <= 0L, a >= 0L, ),
bor3(peq <= 0L, a >= 0L, ))
expect_equal(or3s(per <= 1L, f >= 1L, ),
bor3(per <= 1L, f >= 1L, ))
expect_equal(or3s(pes <= 9L, i >= 9L, ),
bor3(pes <= 9L, i >= 9L, ))
expect_equal(or3s(pet <= 0L, y >= 0L, i >= 0L),
bor3(pet <= 0L, y >= 0L, i >= 0L))
expect_equal(or3s(peu <= 1L, c >= 1L, h >= 1L),
bor3(peu <= 1L, c >= 1L, h >= 1L))
expect_equal(or3s(pev <= 9L, k >= 9L, i >= 9L),
bor3(pev <= 9L, k >= 9L, i >= 9L))
expect_equal(or3s(pew == 0L, , ),
bor3(pew == 0L, , ))
expect_equal(or3s(pex == 1L, , ),
bor3(pex == 1L, , ))
expect_equal(or3s(pey == 9L, , ),
bor3(pey == 9L, , ))
expect_equal(or3s(pez == 0L, , logi_p),
bor3(pez == 0L, , logi_p))
expect_equal(or3s(pfa == 1L, , logi_n),
bor3(pfa == 1L, , logi_n))
expect_equal(or3s(pfb == 9L, , logi_t),
bor3(pfb == 9L, , logi_t))
expect_equal(or3s(pfc == 0L, logi_n, ),
bor3(pfc == 0L, logi_n, ))
expect_equal(or3s(pfd == 1L, logi_c, ),
bor3(pfd == 1L, logi_c, ))
expect_equal(or3s(pfe == 9L, logi_k, ),
bor3(pfe == 9L, logi_k, ))
expect_equal(or3s(pff == 0L, logi_u, logi_j),
bor3(pff == 0L, logi_u, logi_j))
expect_equal(or3s(pfg == 1L, logi_m, logi_t),
bor3(pfg == 1L, logi_m, logi_t))
expect_equal(or3s(pfh == 9L, logi_d, logi_e),
bor3(pfh == 9L, logi_d, logi_e))
expect_equal(or3s(pfi == 0L, , ),
bor3(pfi == 0L, , ))
expect_equal(or3s(pfj == 1L, , ),
bor3(pfj == 1L, , ))
expect_equal(or3s(pfk == 9L, , ),
bor3(pfk == 9L, , ))
expect_equal(or3s(pfl == 0L, , !logi_s),
bor3(pfl == 0L, , !logi_s))
expect_equal(or3s(pfm == 1L, , !logi_c),
bor3(pfm == 1L, , !logi_c))
expect_equal(or3s(pfn == 9L, , !logi_u),
bor3(pfn == 9L, , !logi_u))
expect_equal(or3s(pfo == 0L, logi_e, ),
bor3(pfo == 0L, logi_e, ))
expect_equal(or3s(pfp == 1L, logi_i, ),
bor3(pfp == 1L, logi_i, ))
expect_equal(or3s(pfq == 9L, logi_l, ),
bor3(pfq == 9L, logi_l, ))
expect_equal(or3s(pfr == 0L, logi_s, !logi_h),
bor3(pfr == 0L, logi_s, !logi_h))
expect_equal(or3s(pfs == 1L, logi_v, !logi_o),
bor3(pfs == 1L, logi_v, !logi_o))
expect_equal(or3s(pft == 9L, logi_l, !logi_l),
bor3(pft == 9L, logi_l, !logi_l))
expect_equal(or3s(pfu == 0L, , ),
bor3(pfu == 0L, , ))
expect_equal(or3s(pfv == 1L, , ),
bor3(pfv == 1L, , ))
expect_equal(or3s(pfw == 9L, , ),
bor3(pfw == 9L, , ))
expect_equal(or3s(pfx == 0L, , g != 0L),
bor3(pfx == 0L, , g != 0L))
expect_equal(or3s(pfy == 1L, , f != 1L),
bor3(pfy == 1L, , f != 1L))
expect_equal(or3s(pfz == 9L, , e != 9L),
bor3(pfz == 9L, , e != 9L))
expect_equal(or3s(pga == 0L, logi_v, ),
bor3(pga == 0L, logi_v, ))
expect_equal(or3s(pgb == 1L, logi_z, ),
bor3(pgb == 1L, logi_z, ))
expect_equal(or3s(pgc == 9L, logi_m, ),
bor3(pgc == 9L, logi_m, ))
expect_equal(or3s(pgd == 0L, logi_s, s != 0L),
bor3(pgd == 0L, logi_s, s != 0L))
expect_equal(or3s(pge == 1L, logi_o, e != 1L),
bor3(pge == 1L, logi_o, e != 1L))
expect_equal(or3s(pgf == 9L, logi_w, h != 9L),
bor3(pgf == 9L, logi_w, h != 9L))
expect_equal(or3s(pgg == 0L, , ),
bor3(pgg == 0L, , ))
expect_equal(or3s(pgh == 1L, , ),
bor3(pgh == 1L, , ))
expect_equal(or3s(pgi == 9L, , ),
bor3(pgi == 9L, , ))
expect_equal(or3s(pgj == 0L, , x %between% c(-1L, 1L)),
bor3(pgj == 0L, , x %between% c(-1L, 1L)))
expect_equal(or3s(pgk == 1L, , y %between% c(-1L, 1L)),
bor3(pgk == 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(pgl == 9L, , v %between% c(-1L, 1L)),
bor3(pgl == 9L, , v %between% c(-1L, 1L)))
expect_equal(or3s(pgm == 0L, logi_d, ),
bor3(pgm == 0L, logi_d, ))
expect_equal(or3s(pgn == 1L, logi_i, ),
bor3(pgn == 1L, logi_i, ))
expect_equal(or3s(pgo == 9L, logi_m, ),
bor3(pgo == 9L, logi_m, ))
expect_equal(or3s(pgp == 0L, logi_n, t %between% c(-1L, 1L)),
bor3(pgp == 0L, logi_n, t %between% c(-1L, 1L)))
expect_equal(or3s(pgq == 1L, logi_o, k %between% c(-1L, 1L)),
bor3(pgq == 1L, logi_o, k %between% c(-1L, 1L)))
expect_equal(or3s(pgr == 9L, logi_m, g %between% c(-1L, 1L)),
bor3(pgr == 9L, logi_m, g %between% c(-1L, 1L)))
expect_equal(or3s(pgs == 0L, , ),
bor3(pgs == 0L, , ))
expect_equal(or3s(pgt == 1L, , ),
bor3(pgt == 1L, , ))
expect_equal(or3s(pgu == 9L, , ),
bor3(pgu == 9L, , ))
expect_equal(or3s(pgv == 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pgv == 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pgw == 1L, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pgw == 1L, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pgx == 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pgx == 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pgy == 0L, logi_k, ),
bor3(pgy == 0L, logi_k, ))
expect_equal(or3s(pgz == 1L, logi_d, ),
bor3(pgz == 1L, logi_d, ))
expect_equal(or3s(pha == 9L, logi_q, ),
bor3(pha == 9L, logi_q, ))
expect_equal(or3s(phb == 0L, logi_z, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(phb == 0L, logi_z, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(phc == 1L, logi_z, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(phc == 1L, logi_z, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(phd == 9L, logi_p, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(phd == 9L, logi_p, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(phe == 0L, , ),
bor3(phe == 0L, , ))
expect_equal(or3s(phf == 1L, , ),
bor3(phf == 1L, , ))
expect_equal(or3s(phg == 9L, , ),
bor3(phg == 9L, , ))
expect_equal(or3s(phh == 0L, , i %in% 1:4),
bor3(phh == 0L, , i %in% 1:4))
expect_equal(or3s(phi == 1L, , r %in% 1:4),
bor3(phi == 1L, , r %in% 1:4))
expect_equal(or3s(phj == 9L, , e %in% 1:4),
bor3(phj == 9L, , e %in% 1:4))
expect_equal(or3s(phk == 0L, logi_f, ),
bor3(phk == 0L, logi_f, ))
expect_equal(or3s(phl == 1L, logi_x, ),
bor3(phl == 1L, logi_x, ))
expect_equal(or3s(phm == 9L, logi_u, ),
bor3(phm == 9L, logi_u, ))
expect_equal(or3s(phn == 0L, logi_x, c %in% 1:4),
bor3(phn == 0L, logi_x, c %in% 1:4))
expect_equal(or3s(pho == 1L, logi_u, b %in% 1:4),
bor3(pho == 1L, logi_u, b %in% 1:4))
expect_equal(or3s(php == 9L, logi_w, a %in% 1:4),
bor3(php == 9L, logi_w, a %in% 1:4))
expect_equal(or3s(phq == 0L, , ),
bor3(phq == 0L, , ))
expect_equal(or3s(phr == 1L, , ),
bor3(phr == 1L, , ))
expect_equal(or3s(phs == 9L, , ),
bor3(phs == 9L, , ))
expect_equal(or3s(pht == 0L, , l < 0L),
bor3(pht == 0L, , l < 0L))
expect_equal(or3s(phu == 1L, , n < 1L),
bor3(phu == 1L, , n < 1L))
expect_equal(or3s(phv == 9L, , x < 9L),
bor3(phv == 9L, , x < 9L))
expect_equal(or3s(phw == 0L, logi_p, ),
bor3(phw == 0L, logi_p, ))
expect_equal(or3s(phx == 1L, logi_f, ),
bor3(phx == 1L, logi_f, ))
expect_equal(or3s(phy == 9L, logi_o, ),
bor3(phy == 9L, logi_o, ))
expect_equal(or3s(phz == 0L, logi_o, v < 0L),
bor3(phz == 0L, logi_o, v < 0L))
expect_equal(or3s(pia == 1L, logi_y, b < 1L),
bor3(pia == 1L, logi_y, b < 1L))
expect_equal(or3s(pib == 9L, logi_g, p < 9L),
bor3(pib == 9L, logi_g, p < 9L))
expect_equal(or3s(pic == 0L, , ),
bor3(pic == 0L, , ))
expect_equal(or3s(pid == 1L, , ),
bor3(pid == 1L, , ))
expect_equal(or3s(pie == 9L, , ),
bor3(pie == 9L, , ))
expect_equal(or3s(pif == 0L, , d <= 0L),
bor3(pif == 0L, , d <= 0L))
expect_equal(or3s(pig == 1L, , j <= 1L),
bor3(pig == 1L, , j <= 1L))
expect_equal(or3s(pih == 9L, , l <= 9L),
bor3(pih == 9L, , l <= 9L))
expect_equal(or3s(pii == 0L, logi_u, ),
bor3(pii == 0L, logi_u, ))
expect_equal(or3s(pij == 1L, logi_r, ),
bor3(pij == 1L, logi_r, ))
expect_equal(or3s(pik == 9L, logi_l, ),
bor3(pik == 9L, logi_l, ))
expect_equal(or3s(pil == 0L, logi_f, d <= 0L),
bor3(pil == 0L, logi_f, d <= 0L))
expect_equal(or3s(pim == 1L, logi_u, e <= 1L),
bor3(pim == 1L, logi_u, e <= 1L))
expect_equal(or3s(pin == 9L, logi_u, a <= 9L),
bor3(pin == 9L, logi_u, a <= 9L))
expect_equal(or3s(pio == 0L, , ),
bor3(pio == 0L, , ))
expect_equal(or3s(pip == 1L, , ),
bor3(pip == 1L, , ))
expect_equal(or3s(piq == 9L, , ),
bor3(piq == 9L, , ))
expect_equal(or3s(pir == 0L, , n == 0L),
bor3(pir == 0L, , n == 0L))
expect_equal(or3s(pis == 1L, , w == 1L),
bor3(pis == 1L, , w == 1L))
expect_equal(or3s(pit == 9L, , h == 9L),
bor3(pit == 9L, , h == 9L))
expect_equal(or3s(piu == 0L, logi_t, ),
bor3(piu == 0L, logi_t, ))
expect_equal(or3s(piv == 1L, logi_o, ),
bor3(piv == 1L, logi_o, ))
expect_equal(or3s(piw == 9L, logi_q, ),
bor3(piw == 9L, logi_q, ))
expect_equal(or3s(pix == 0L, logi_q, e == 0L),
bor3(pix == 0L, logi_q, e == 0L))
expect_equal(or3s(piy == 1L, logi_e, u == 1L),
bor3(piy == 1L, logi_e, u == 1L))
expect_equal(or3s(piz == 9L, logi_x, y == 9L),
bor3(piz == 9L, logi_x, y == 9L))
expect_equal(or3s(pja == 0L, , ),
bor3(pja == 0L, , ))
expect_equal(or3s(pjb == 1L, , ),
bor3(pjb == 1L, , ))
expect_equal(or3s(pjc == 9L, , ),
bor3(pjc == 9L, , ))
expect_equal(or3s(pjd == 0L, , n > 0L),
bor3(pjd == 0L, , n > 0L))
expect_equal(or3s(pje == 1L, , w > 1L),
bor3(pje == 1L, , w > 1L))
expect_equal(or3s(pjf == 9L, , w > 9L),
bor3(pjf == 9L, , w > 9L))
expect_equal(or3s(pjg == 0L, logi_b, ),
bor3(pjg == 0L, logi_b, ))
expect_equal(or3s(pjh == 1L, logi_q, ),
bor3(pjh == 1L, logi_q, ))
expect_equal(or3s(pji == 9L, logi_v, ),
bor3(pji == 9L, logi_v, ))
expect_equal(or3s(pjj == 0L, logi_p, h > 0L),
bor3(pjj == 0L, logi_p, h > 0L))
expect_equal(or3s(pjk == 1L, logi_u, f > 1L),
bor3(pjk == 1L, logi_u, f > 1L))
expect_equal(or3s(pjl == 9L, logi_j, p > 9L),
bor3(pjl == 9L, logi_j, p > 9L))
expect_equal(or3s(pjm == 0L, , ),
bor3(pjm == 0L, , ))
expect_equal(or3s(pjn == 1L, , ),
bor3(pjn == 1L, , ))
expect_equal(or3s(pjo == 9L, , ),
bor3(pjo == 9L, , ))
expect_equal(or3s(pjp == 0L, , o >= 0L),
bor3(pjp == 0L, , o >= 0L))
expect_equal(or3s(pjq == 1L, , e >= 1L),
bor3(pjq == 1L, , e >= 1L))
expect_equal(or3s(pjr == 9L, , q >= 9L),
bor3(pjr == 9L, , q >= 9L))
expect_equal(or3s(pjs == 0L, logi_a, ),
bor3(pjs == 0L, logi_a, ))
expect_equal(or3s(pjt == 1L, logi_t, ),
bor3(pjt == 1L, logi_t, ))
expect_equal(or3s(pju == 9L, logi_h, ),
bor3(pju == 9L, logi_h, ))
expect_equal(or3s(pjv == 0L, logi_s, k >= 0L),
bor3(pjv == 0L, logi_s, k >= 0L))
expect_equal(or3s(pjw == 1L, logi_r, e >= 1L),
bor3(pjw == 1L, logi_r, e >= 1L))
expect_equal(or3s(pjx == 9L, logi_j, g >= 9L),
bor3(pjx == 9L, logi_j, g >= 9L))
expect_equal(or3s(pjy == 0L, , ),
bor3(pjy == 0L, , ))
expect_equal(or3s(pjz == 1L, , ),
bor3(pjz == 1L, , ))
expect_equal(or3s(pka == 9L, , ),
bor3(pka == 9L, , ))
expect_equal(or3s(pkb == 0L, , logi_o),
bor3(pkb == 0L, , logi_o))
expect_equal(or3s(pkc == 1L, , logi_g),
bor3(pkc == 1L, , logi_g))
expect_equal(or3s(pkd == 9L, , logi_u),
bor3(pkd == 9L, , logi_u))
expect_equal(or3s(pke == 0L, !logi_l, ),
bor3(pke == 0L, !logi_l, ))
expect_equal(or3s(pkf == 1L, !logi_g, ),
bor3(pkf == 1L, !logi_g, ))
expect_equal(or3s(pkg == 9L, !logi_z, ),
bor3(pkg == 9L, !logi_z, ))
expect_equal(or3s(pkh == 0L, !logi_l, logi_m),
bor3(pkh == 0L, !logi_l, logi_m))
expect_equal(or3s(pki == 1L, !logi_y, logi_p),
bor3(pki == 1L, !logi_y, logi_p))
expect_equal(or3s(pkj == 9L, !logi_v, logi_y),
bor3(pkj == 9L, !logi_v, logi_y))
expect_equal(or3s(pkk == 0L, , ),
bor3(pkk == 0L, , ))
expect_equal(or3s(pkl == 1L, , ),
bor3(pkl == 1L, , ))
expect_equal(or3s(pkm == 9L, , ),
bor3(pkm == 9L, , ))
expect_equal(or3s(pkn == 0L, , !logi_i),
bor3(pkn == 0L, , !logi_i))
expect_equal(or3s(pko == 1L, , !logi_l),
bor3(pko == 1L, , !logi_l))
expect_equal(or3s(pkp == 9L, , !logi_a),
bor3(pkp == 9L, , !logi_a))
expect_equal(or3s(pkq == 0L, !logi_r, ),
bor3(pkq == 0L, !logi_r, ))
expect_equal(or3s(pkr == 1L, !logi_l, ),
bor3(pkr == 1L, !logi_l, ))
expect_equal(or3s(pks == 9L, !logi_u, ),
bor3(pks == 9L, !logi_u, ))
expect_equal(or3s(pkt == 0L, !logi_i, !logi_o),
bor3(pkt == 0L, !logi_i, !logi_o))
expect_equal(or3s(pku == 1L, !logi_l, !logi_x),
bor3(pku == 1L, !logi_l, !logi_x))
expect_equal(or3s(pkv == 9L, !logi_p, !logi_f),
bor3(pkv == 9L, !logi_p, !logi_f))
expect_equal(or3s(pkw == 0L, , ),
bor3(pkw == 0L, , ))
expect_equal(or3s(pkx == 1L, , ),
bor3(pkx == 1L, , ))
expect_equal(or3s(pky == 9L, , ),
bor3(pky == 9L, , ))
expect_equal(or3s(pkz == 0L, , t != 0L),
bor3(pkz == 0L, , t != 0L))
expect_equal(or3s(pla == 1L, , p != 1L),
bor3(pla == 1L, , p != 1L))
expect_equal(or3s(plb == 9L, , m != 9L),
bor3(plb == 9L, , m != 9L))
expect_equal(or3s(plc == 0L, !logi_f, ),
bor3(plc == 0L, !logi_f, ))
expect_equal(or3s(pld == 1L, !logi_p, ),
bor3(pld == 1L, !logi_p, ))
expect_equal(or3s(ple == 9L, !logi_e, ),
bor3(ple == 9L, !logi_e, ))
expect_equal(or3s(plf == 0L, !logi_q, a != 0L),
bor3(plf == 0L, !logi_q, a != 0L))
expect_equal(or3s(plg == 1L, !logi_i, p != 1L),
bor3(plg == 1L, !logi_i, p != 1L))
expect_equal(or3s(plh == 9L, !logi_o, c != 9L),
bor3(plh == 9L, !logi_o, c != 9L))
expect_equal(or3s(pli == 0L, , ),
bor3(pli == 0L, , ))
expect_equal(or3s(plj == 1L, , ),
bor3(plj == 1L, , ))
expect_equal(or3s(plk == 9L, , ),
bor3(plk == 9L, , ))
expect_equal(or3s(pll == 0L, , d %between% c(-1L, 1L)),
bor3(pll == 0L, , d %between% c(-1L, 1L)))
expect_equal(or3s(plm == 1L, , t %between% c(-1L, 1L)),
bor3(plm == 1L, , t %between% c(-1L, 1L)))
expect_equal(or3s(pln == 9L, , b %between% c(-1L, 1L)),
bor3(pln == 9L, , b %between% c(-1L, 1L)))
expect_equal(or3s(plo == 0L, !logi_p, ),
bor3(plo == 0L, !logi_p, ))
expect_equal(or3s(plp == 1L, !logi_v, ),
bor3(plp == 1L, !logi_v, ))
expect_equal(or3s(plq == 9L, !logi_w, ),
bor3(plq == 9L, !logi_w, ))
expect_equal(or3s(plr == 0L, !logi_z, d %between% c(-1L, 1L)),
bor3(plr == 0L, !logi_z, d %between% c(-1L, 1L)))
expect_equal(or3s(pls == 1L, !logi_e, q %between% c(-1L, 1L)),
bor3(pls == 1L, !logi_e, q %between% c(-1L, 1L)))
expect_equal(or3s(plt == 9L, !logi_s, v %between% c(-1L, 1L)),
bor3(plt == 9L, !logi_s, v %between% c(-1L, 1L)))
expect_equal(or3s(plu == 0L, , ),
bor3(plu == 0L, , ))
expect_equal(or3s(plv == 1L, , ),
bor3(plv == 1L, , ))
expect_equal(or3s(plw == 9L, , ),
bor3(plw == 9L, , ))
expect_equal(or3s(plx == 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(plx == 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ply == 1L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ply == 1L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(plz == 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(plz == 9L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pma == 0L, !logi_v, ),
bor3(pma == 0L, !logi_v, ))
expect_equal(or3s(pmb == 1L, !logi_t, ),
bor3(pmb == 1L, !logi_t, ))
expect_equal(or3s(pmc == 9L, !logi_a, ),
bor3(pmc == 9L, !logi_a, ))
expect_equal(or3s(pmd == 0L, !logi_d, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pmd == 0L, !logi_d, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pme == 1L, !logi_a, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pme == 1L, !logi_a, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pmf == 9L, !logi_v, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pmf == 9L, !logi_v, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pmg == 0L, , ),
bor3(pmg == 0L, , ))
expect_equal(or3s(pmh == 1L, , ),
bor3(pmh == 1L, , ))
expect_equal(or3s(pmi == 9L, , ),
bor3(pmi == 9L, , ))
expect_equal(or3s(pmj == 0L, , o %in% 1:4),
bor3(pmj == 0L, , o %in% 1:4))
expect_equal(or3s(pmk == 1L, , t %in% 1:4),
bor3(pmk == 1L, , t %in% 1:4))
expect_equal(or3s(pml == 9L, , n %in% 1:4),
bor3(pml == 9L, , n %in% 1:4))
expect_equal(or3s(pmm == 0L, !logi_y, ),
bor3(pmm == 0L, !logi_y, ))
expect_equal(or3s(pmn == 1L, !logi_e, ),
bor3(pmn == 1L, !logi_e, ))
expect_equal(or3s(pmo == 9L, !logi_f, ),
bor3(pmo == 9L, !logi_f, ))
expect_equal(or3s(pmp == 0L, !logi_d, u %in% 1:4),
bor3(pmp == 0L, !logi_d, u %in% 1:4))
expect_equal(or3s(pmq == 1L, !logi_t, s %in% 1:4),
bor3(pmq == 1L, !logi_t, s %in% 1:4))
expect_equal(or3s(pmr == 9L, !logi_x, q %in% 1:4),
bor3(pmr == 9L, !logi_x, q %in% 1:4))
expect_equal(or3s(pms == 0L, , ),
bor3(pms == 0L, , ))
expect_equal(or3s(pmt == 1L, , ),
bor3(pmt == 1L, , ))
expect_equal(or3s(pmu == 9L, , ),
bor3(pmu == 9L, , ))
expect_equal(or3s(pmv == 0L, , z < 0L),
bor3(pmv == 0L, , z < 0L))
expect_equal(or3s(pmw == 1L, , q < 1L),
bor3(pmw == 1L, , q < 1L))
expect_equal(or3s(pmx == 9L, , l < 9L),
bor3(pmx == 9L, , l < 9L))
expect_equal(or3s(pmy == 0L, !logi_x, ),
bor3(pmy == 0L, !logi_x, ))
expect_equal(or3s(pmz == 1L, !logi_s, ),
bor3(pmz == 1L, !logi_s, ))
expect_equal(or3s(pna == 9L, !logi_h, ),
bor3(pna == 9L, !logi_h, ))
expect_equal(or3s(pnb == 0L, !logi_p, e < 0L),
bor3(pnb == 0L, !logi_p, e < 0L))
expect_equal(or3s(pnc == 1L, !logi_v, s < 1L),
bor3(pnc == 1L, !logi_v, s < 1L))
expect_equal(or3s(pnd == 9L, !logi_q, u < 9L),
bor3(pnd == 9L, !logi_q, u < 9L))
expect_equal(or3s(pne == 0L, , ),
bor3(pne == 0L, , ))
expect_equal(or3s(pnf == 1L, , ),
bor3(pnf == 1L, , ))
expect_equal(or3s(png == 9L, , ),
bor3(png == 9L, , ))
expect_equal(or3s(pnh == 0L, , u <= 0L),
bor3(pnh == 0L, , u <= 0L))
expect_equal(or3s(pni == 1L, , n <= 1L),
bor3(pni == 1L, , n <= 1L))
expect_equal(or3s(pnj == 9L, , h <= 9L),
bor3(pnj == 9L, , h <= 9L))
expect_equal(or3s(pnk == 0L, !logi_f, ),
bor3(pnk == 0L, !logi_f, ))
expect_equal(or3s(pnl == 1L, !logi_a, ),
bor3(pnl == 1L, !logi_a, ))
expect_equal(or3s(pnm == 9L, !logi_e, ),
bor3(pnm == 9L, !logi_e, ))
expect_equal(or3s(pnn == 0L, !logi_f, e <= 0L),
bor3(pnn == 0L, !logi_f, e <= 0L))
expect_equal(or3s(pno == 1L, !logi_w, d <= 1L),
bor3(pno == 1L, !logi_w, d <= 1L))
expect_equal(or3s(pnp == 9L, !logi_p, i <= 9L),
bor3(pnp == 9L, !logi_p, i <= 9L))
expect_equal(or3s(pnq == 0L, , ),
bor3(pnq == 0L, , ))
expect_equal(or3s(pnr == 1L, , ),
bor3(pnr == 1L, , ))
expect_equal(or3s(pns == 9L, , ),
bor3(pns == 9L, , ))
expect_equal(or3s(pnt == 0L, , c == 0L),
bor3(pnt == 0L, , c == 0L))
expect_equal(or3s(pnu == 1L, , g == 1L),
bor3(pnu == 1L, , g == 1L))
expect_equal(or3s(pnv == 9L, , j == 9L),
bor3(pnv == 9L, , j == 9L))
expect_equal(or3s(pnw == 0L, !logi_c, ),
bor3(pnw == 0L, !logi_c, ))
expect_equal(or3s(pnx == 1L, !logi_g, ),
bor3(pnx == 1L, !logi_g, ))
expect_equal(or3s(pny == 9L, !logi_b, ),
bor3(pny == 9L, !logi_b, ))
expect_equal(or3s(pnz == 0L, !logi_h, f == 0L),
bor3(pnz == 0L, !logi_h, f == 0L))
expect_equal(or3s(poa == 1L, !logi_m, i == 1L),
bor3(poa == 1L, !logi_m, i == 1L))
expect_equal(or3s(pob == 9L, !logi_q, m == 9L),
bor3(pob == 9L, !logi_q, m == 9L))
expect_equal(or3s(poc == 0L, , ),
bor3(poc == 0L, , ))
expect_equal(or3s(pod == 1L, , ),
bor3(pod == 1L, , ))
expect_equal(or3s(poe == 9L, , ),
bor3(poe == 9L, , ))
expect_equal(or3s(pof == 0L, , o > 0L),
bor3(pof == 0L, , o > 0L))
expect_equal(or3s(pog == 1L, , j > 1L),
bor3(pog == 1L, , j > 1L))
expect_equal(or3s(poh == 9L, , u > 9L),
bor3(poh == 9L, , u > 9L))
expect_equal(or3s(poi == 0L, !logi_n, ),
bor3(poi == 0L, !logi_n, ))
expect_equal(or3s(poj == 1L, !logi_w, ),
bor3(poj == 1L, !logi_w, ))
expect_equal(or3s(pok == 9L, !logi_k, ),
bor3(pok == 9L, !logi_k, ))
expect_equal(or3s(pol == 0L, !logi_o, k > 0L),
bor3(pol == 0L, !logi_o, k > 0L))
expect_equal(or3s(pom == 1L, !logi_b, h > 1L),
bor3(pom == 1L, !logi_b, h > 1L))
expect_equal(or3s(pon == 9L, !logi_b, v > 9L),
bor3(pon == 9L, !logi_b, v > 9L))
expect_equal(or3s(poo == 0L, , ),
bor3(poo == 0L, , ))
expect_equal(or3s(pop == 1L, , ),
bor3(pop == 1L, , ))
expect_equal(or3s(poq == 9L, , ),
bor3(poq == 9L, , ))
expect_equal(or3s(por == 0L, , w >= 0L),
bor3(por == 0L, , w >= 0L))
expect_equal(or3s(pos == 1L, , z >= 1L),
bor3(pos == 1L, , z >= 1L))
expect_equal(or3s(pot == 9L, , l >= 9L),
bor3(pot == 9L, , l >= 9L))
expect_equal(or3s(pou == 0L, !logi_a, ),
bor3(pou == 0L, !logi_a, ))
expect_equal(or3s(pov == 1L, !logi_r, ),
bor3(pov == 1L, !logi_r, ))
expect_equal(or3s(pow == 9L, !logi_g, ),
bor3(pow == 9L, !logi_g, ))
expect_equal(or3s(pox == 0L, !logi_a, l >= 0L),
bor3(pox == 0L, !logi_a, l >= 0L))
expect_equal(or3s(poy == 1L, !logi_w, f >= 1L),
bor3(poy == 1L, !logi_w, f >= 1L))
expect_equal(or3s(poz == 9L, !logi_n, p >= 9L),
bor3(poz == 9L, !logi_n, p >= 9L))
expect_equal(or3s(ppa == 0L, , ),
bor3(ppa == 0L, , ))
expect_equal(or3s(ppb == 1L, , ),
bor3(ppb == 1L, , ))
expect_equal(or3s(ppc == 9L, , ),
bor3(ppc == 9L, , ))
expect_equal(or3s(ppd == 0L, , logi_b),
bor3(ppd == 0L, , logi_b))
expect_equal(or3s(ppe == 1L, , logi_f),
bor3(ppe == 1L, , logi_f))
expect_equal(or3s(ppf == 9L, , logi_z),
bor3(ppf == 9L, , logi_z))
expect_equal(or3s(ppg == 0L, g != 0L, ),
bor3(ppg == 0L, g != 0L, ))
expect_equal(or3s(pph == 1L, d != 1L, ),
bor3(pph == 1L, d != 1L, ))
expect_equal(or3s(ppi == 9L, h != 9L, ),
bor3(ppi == 9L, h != 9L, ))
expect_equal(or3s(ppj == 0L, f != 0L, logi_y),
bor3(ppj == 0L, f != 0L, logi_y))
expect_equal(or3s(ppk == 1L, y != 1L, logi_d),
bor3(ppk == 1L, y != 1L, logi_d))
expect_equal(or3s(ppl == 9L, s != 9L, logi_y),
bor3(ppl == 9L, s != 9L, logi_y))
expect_equal(or3s(ppm == 0L, , ),
bor3(ppm == 0L, , ))
expect_equal(or3s(ppn == 1L, , ),
bor3(ppn == 1L, , ))
expect_equal(or3s(ppo == 9L, , ),
bor3(ppo == 9L, , ))
expect_equal(or3s(ppp == 0L, , !logi_k),
bor3(ppp == 0L, , !logi_k))
expect_equal(or3s(ppq == 1L, , !logi_z),
bor3(ppq == 1L, , !logi_z))
expect_equal(or3s(ppr == 9L, , !logi_r),
bor3(ppr == 9L, , !logi_r))
expect_equal(or3s(pps == 0L, x != 0L, ),
bor3(pps == 0L, x != 0L, ))
expect_equal(or3s(ppt == 1L, w != 1L, ),
bor3(ppt == 1L, w != 1L, ))
expect_equal(or3s(ppu == 9L, p != 9L, ),
bor3(ppu == 9L, p != 9L, ))
expect_equal(or3s(ppv == 0L, c != 0L, !logi_g),
bor3(ppv == 0L, c != 0L, !logi_g))
expect_equal(or3s(ppw == 1L, z != 1L, !logi_z),
bor3(ppw == 1L, z != 1L, !logi_z))
expect_equal(or3s(ppx == 9L, d != 9L, !logi_v),
bor3(ppx == 9L, d != 9L, !logi_v))
expect_equal(or3s(ppy == 0L, , ),
bor3(ppy == 0L, , ))
expect_equal(or3s(ppz == 1L, , ),
bor3(ppz == 1L, , ))
expect_equal(or3s(pqa == 9L, , ),
bor3(pqa == 9L, , ))
expect_equal(or3s(pqb == 0L, , z != 0L),
bor3(pqb == 0L, , z != 0L))
expect_equal(or3s(pqc == 1L, , u != 1L),
bor3(pqc == 1L, , u != 1L))
expect_equal(or3s(pqd == 9L, , g != 9L),
bor3(pqd == 9L, , g != 9L))
expect_equal(or3s(pqe == 0L, z != 0L, ),
bor3(pqe == 0L, z != 0L, ))
expect_equal(or3s(pqf == 1L, s != 1L, ),
bor3(pqf == 1L, s != 1L, ))
expect_equal(or3s(pqg == 9L, a != 9L, ),
bor3(pqg == 9L, a != 9L, ))
expect_equal(or3s(pqh == 0L, o != 0L, i != 0L),
bor3(pqh == 0L, o != 0L, i != 0L))
expect_equal(or3s(pqi == 1L, a != 1L, z != 1L),
bor3(pqi == 1L, a != 1L, z != 1L))
expect_equal(or3s(pqj == 9L, k != 9L, r != 9L),
bor3(pqj == 9L, k != 9L, r != 9L))
expect_equal(or3s(pqk == 0L, , ),
bor3(pqk == 0L, , ))
expect_equal(or3s(pql == 1L, , ),
bor3(pql == 1L, , ))
expect_equal(or3s(pqm == 9L, , ),
bor3(pqm == 9L, , ))
expect_equal(or3s(pqn == 0L, , f %between% c(-1L, 1L)),
bor3(pqn == 0L, , f %between% c(-1L, 1L)))
expect_equal(or3s(pqo == 1L, , p %between% c(-1L, 1L)),
bor3(pqo == 1L, , p %between% c(-1L, 1L)))
expect_equal(or3s(pqp == 9L, , u %between% c(-1L, 1L)),
bor3(pqp == 9L, , u %between% c(-1L, 1L)))
expect_equal(or3s(pqq == 0L, w != 0L, ),
bor3(pqq == 0L, w != 0L, ))
expect_equal(or3s(pqr == 1L, z != 1L, ),
bor3(pqr == 1L, z != 1L, ))
expect_equal(or3s(pqs == 9L, y != 9L, ),
bor3(pqs == 9L, y != 9L, ))
expect_equal(or3s(pqt == 0L, i != 0L, c %between% c(-1L, 1L)),
bor3(pqt == 0L, i != 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(pqu == 1L, j != 1L, o %between% c(-1L, 1L)),
bor3(pqu == 1L, j != 1L, o %between% c(-1L, 1L)))
expect_equal(or3s(pqv == 9L, i != 9L, q %between% c(-1L, 1L)),
bor3(pqv == 9L, i != 9L, q %between% c(-1L, 1L)))
expect_equal(or3s(pqw == 0L, , ),
bor3(pqw == 0L, , ))
expect_equal(or3s(pqx == 1L, , ),
bor3(pqx == 1L, , ))
expect_equal(or3s(pqy == 9L, , ),
bor3(pqy == 9L, , ))
expect_equal(or3s(pqz == 0L, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pqz == 0L, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pra == 1L, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pra == 1L, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(prb == 9L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(prb == 9L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(prc == 0L, k != 0L, ),
bor3(prc == 0L, k != 0L, ))
expect_equal(or3s(prd == 1L, b != 1L, ),
bor3(prd == 1L, b != 1L, ))
expect_equal(or3s(pre == 9L, g != 9L, ),
bor3(pre == 9L, g != 9L, ))
expect_equal(or3s(prf == 0L, m != 0L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(prf == 0L, m != 0L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(prg == 1L, u != 1L, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(prg == 1L, u != 1L, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(prh == 9L, m != 9L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(prh == 9L, m != 9L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pri == 0L, , ),
bor3(pri == 0L, , ))
expect_equal(or3s(prj == 1L, , ),
bor3(prj == 1L, , ))
expect_equal(or3s(prk == 9L, , ),
bor3(prk == 9L, , ))
expect_equal(or3s(prl == 0L, , j %in% 1:4),
bor3(prl == 0L, , j %in% 1:4))
expect_equal(or3s(prm == 1L, , j %in% 1:4),
bor3(prm == 1L, , j %in% 1:4))
expect_equal(or3s(prn == 9L, , f %in% 1:4),
bor3(prn == 9L, , f %in% 1:4))
expect_equal(or3s(pro == 0L, f != 0L, ),
bor3(pro == 0L, f != 0L, ))
expect_equal(or3s(prp == 1L, x != 1L, ),
bor3(prp == 1L, x != 1L, ))
expect_equal(or3s(prq == 9L, v != 9L, ),
bor3(prq == 9L, v != 9L, ))
expect_equal(or3s(prr == 0L, x != 0L, r %in% 1:4),
bor3(prr == 0L, x != 0L, r %in% 1:4))
expect_equal(or3s(prs == 1L, w != 1L, a %in% 1:4),
bor3(prs == 1L, w != 1L, a %in% 1:4))
expect_equal(or3s(prt == 9L, c != 9L, u %in% 1:4),
bor3(prt == 9L, c != 9L, u %in% 1:4))
expect_equal(or3s(pru == 0L, , ),
bor3(pru == 0L, , ))
expect_equal(or3s(prv == 1L, , ),
bor3(prv == 1L, , ))
expect_equal(or3s(prw == 9L, , ),
bor3(prw == 9L, , ))
expect_equal(or3s(prx == 0L, , y < 0L),
bor3(prx == 0L, , y < 0L))
expect_equal(or3s(pry == 1L, , t < 1L),
bor3(pry == 1L, , t < 1L))
expect_equal(or3s(prz == 9L, , s < 9L),
bor3(prz == 9L, , s < 9L))
expect_equal(or3s(psa == 0L, s != 0L, ),
bor3(psa == 0L, s != 0L, ))
expect_equal(or3s(psb == 1L, t != 1L, ),
bor3(psb == 1L, t != 1L, ))
expect_equal(or3s(psc == 9L, e != 9L, ),
bor3(psc == 9L, e != 9L, ))
expect_equal(or3s(psd == 0L, g != 0L, x < 0L),
bor3(psd == 0L, g != 0L, x < 0L))
expect_equal(or3s(pse == 1L, n != 1L, r < 1L),
bor3(pse == 1L, n != 1L, r < 1L))
expect_equal(or3s(psf == 9L, h != 9L, l < 9L),
bor3(psf == 9L, h != 9L, l < 9L))
expect_equal(or3s(psg == 0L, , ),
bor3(psg == 0L, , ))
expect_equal(or3s(psh == 1L, , ),
bor3(psh == 1L, , ))
expect_equal(or3s(psi == 9L, , ),
bor3(psi == 9L, , ))
expect_equal(or3s(psj == 0L, , v <= 0L),
bor3(psj == 0L, , v <= 0L))
expect_equal(or3s(psk == 1L, , c <= 1L),
bor3(psk == 1L, , c <= 1L))
expect_equal(or3s(psl == 9L, , i <= 9L),
bor3(psl == 9L, , i <= 9L))
expect_equal(or3s(psm == 0L, o != 0L, ),
bor3(psm == 0L, o != 0L, ))
expect_equal(or3s(psn == 1L, k != 1L, ),
bor3(psn == 1L, k != 1L, ))
expect_equal(or3s(pso == 9L, m != 9L, ),
bor3(pso == 9L, m != 9L, ))
expect_equal(or3s(psp == 0L, u != 0L, e <= 0L),
bor3(psp == 0L, u != 0L, e <= 0L))
expect_equal(or3s(psq == 1L, q != 1L, c <= 1L),
bor3(psq == 1L, q != 1L, c <= 1L))
expect_equal(or3s(psr == 9L, v != 9L, l <= 9L),
bor3(psr == 9L, v != 9L, l <= 9L))
expect_equal(or3s(pss == 0L, , ),
bor3(pss == 0L, , ))
expect_equal(or3s(pst == 1L, , ),
bor3(pst == 1L, , ))
expect_equal(or3s(psu == 9L, , ),
bor3(psu == 9L, , ))
expect_equal(or3s(psv == 0L, , p == 0L),
bor3(psv == 0L, , p == 0L))
expect_equal(or3s(psw == 1L, , z == 1L),
bor3(psw == 1L, , z == 1L))
expect_equal(or3s(psx == 9L, , c == 9L),
bor3(psx == 9L, , c == 9L))
expect_equal(or3s(psy == 0L, v != 0L, ),
bor3(psy == 0L, v != 0L, ))
expect_equal(or3s(psz == 1L, f != 1L, ),
bor3(psz == 1L, f != 1L, ))
expect_equal(or3s(pta == 9L, i != 9L, ),
bor3(pta == 9L, i != 9L, ))
expect_equal(or3s(ptb == 0L, t != 0L, g == 0L),
bor3(ptb == 0L, t != 0L, g == 0L))
expect_equal(or3s(ptc == 1L, x != 1L, r == 1L),
bor3(ptc == 1L, x != 1L, r == 1L))
expect_equal(or3s(ptd == 9L, m != 9L, h == 9L),
bor3(ptd == 9L, m != 9L, h == 9L))
expect_equal(or3s(pte == 0L, , ),
bor3(pte == 0L, , ))
expect_equal(or3s(ptf == 1L, , ),
bor3(ptf == 1L, , ))
expect_equal(or3s(ptg == 9L, , ),
bor3(ptg == 9L, , ))
expect_equal(or3s(pth == 0L, , c > 0L),
bor3(pth == 0L, , c > 0L))
expect_equal(or3s(pti == 1L, , k > 1L),
bor3(pti == 1L, , k > 1L))
expect_equal(or3s(ptj == 9L, , f > 9L),
bor3(ptj == 9L, , f > 9L))
expect_equal(or3s(ptk == 0L, a != 0L, ),
bor3(ptk == 0L, a != 0L, ))
expect_equal(or3s(ptl == 1L, l != 1L, ),
bor3(ptl == 1L, l != 1L, ))
expect_equal(or3s(ptm == 9L, d != 9L, ),
bor3(ptm == 9L, d != 9L, ))
expect_equal(or3s(ptn == 0L, d != 0L, t > 0L),
bor3(ptn == 0L, d != 0L, t > 0L))
expect_equal(or3s(pto == 1L, j != 1L, a > 1L),
bor3(pto == 1L, j != 1L, a > 1L))
expect_equal(or3s(ptp == 9L, z != 9L, y > 9L),
bor3(ptp == 9L, z != 9L, y > 9L))
expect_equal(or3s(ptq == 0L, , ),
bor3(ptq == 0L, , ))
expect_equal(or3s(ptr == 1L, , ),
bor3(ptr == 1L, , ))
expect_equal(or3s(pts == 9L, , ),
bor3(pts == 9L, , ))
expect_equal(or3s(ptt == 0L, , k >= 0L),
bor3(ptt == 0L, , k >= 0L))
expect_equal(or3s(ptu == 1L, , n >= 1L),
bor3(ptu == 1L, , n >= 1L))
expect_equal(or3s(ptv == 9L, , m >= 9L),
bor3(ptv == 9L, , m >= 9L))
expect_equal(or3s(ptw == 0L, b != 0L, ),
bor3(ptw == 0L, b != 0L, ))
expect_equal(or3s(ptx == 1L, w != 1L, ),
bor3(ptx == 1L, w != 1L, ))
expect_equal(or3s(pty == 9L, f != 9L, ),
bor3(pty == 9L, f != 9L, ))
expect_equal(or3s(ptz == 0L, a != 0L, z >= 0L),
bor3(ptz == 0L, a != 0L, z >= 0L))
expect_equal(or3s(pua == 1L, a != 1L, n >= 1L),
bor3(pua == 1L, a != 1L, n >= 1L))
expect_equal(or3s(pub == 9L, f != 9L, v >= 9L),
bor3(pub == 9L, f != 9L, v >= 9L))
expect_equal(or3s(puc == 0L, , ),
bor3(puc == 0L, , ))
expect_equal(or3s(pud == 1L, , ),
bor3(pud == 1L, , ))
expect_equal(or3s(pue == 9L, , ),
bor3(pue == 9L, , ))
expect_equal(or3s(puf == 0L, , logi_w),
bor3(puf == 0L, , logi_w))
expect_equal(or3s(pug == 1L, , logi_o),
bor3(pug == 1L, , logi_o))
expect_equal(or3s(puh == 9L, , logi_m),
bor3(puh == 9L, , logi_m))
expect_equal(or3s(pui == 0L, r %between% c(-1L, 1L), ),
bor3(pui == 0L, r %between% c(-1L, 1L), ))
expect_equal(or3s(puj == 1L, u %between% c(-1L, 1L), ),
bor3(puj == 1L, u %between% c(-1L, 1L), ))
expect_equal(or3s(puk == 9L, c %between% c(-1L, 1L), ),
bor3(puk == 9L, c %between% c(-1L, 1L), ))
expect_equal(or3s(pul == 0L, i %between% c(-1L, 1L), logi_u),
bor3(pul == 0L, i %between% c(-1L, 1L), logi_u))
expect_equal(or3s(pum == 1L, b %between% c(-1L, 1L), logi_n),
bor3(pum == 1L, b %between% c(-1L, 1L), logi_n))
expect_equal(or3s(pun == 9L, f %between% c(-1L, 1L), logi_w),
bor3(pun == 9L, f %between% c(-1L, 1L), logi_w))
expect_equal(or3s(puo == 0L, , ),
bor3(puo == 0L, , ))
expect_equal(or3s(pup == 1L, , ),
bor3(pup == 1L, , ))
expect_equal(or3s(puq == 9L, , ),
bor3(puq == 9L, , ))
expect_equal(or3s(pur == 0L, , !logi_l),
bor3(pur == 0L, , !logi_l))
expect_equal(or3s(pus == 1L, , !logi_i),
bor3(pus == 1L, , !logi_i))
expect_equal(or3s(put == 9L, , !logi_r),
bor3(put == 9L, , !logi_r))
expect_equal(or3s(puu == 0L, h %between% c(-1L, 1L), ),
bor3(puu == 0L, h %between% c(-1L, 1L), ))
expect_equal(or3s(puv == 1L, k %between% c(-1L, 1L), ),
bor3(puv == 1L, k %between% c(-1L, 1L), ))
expect_equal(or3s(puw == 9L, y %between% c(-1L, 1L), ),
bor3(puw == 9L, y %between% c(-1L, 1L), ))
expect_equal(or3s(pux == 0L, b %between% c(-1L, 1L), !logi_w),
bor3(pux == 0L, b %between% c(-1L, 1L), !logi_w))
expect_equal(or3s(puy == 1L, k %between% c(-1L, 1L), !logi_k),
bor3(puy == 1L, k %between% c(-1L, 1L), !logi_k))
expect_equal(or3s(puz == 9L, k %between% c(-1L, 1L), !logi_i),
bor3(puz == 9L, k %between% c(-1L, 1L), !logi_i))
expect_equal(or3s(pva == 0L, , ),
bor3(pva == 0L, , ))
expect_equal(or3s(pvb == 1L, , ),
bor3(pvb == 1L, , ))
expect_equal(or3s(pvc == 9L, , ),
bor3(pvc == 9L, , ))
expect_equal(or3s(pvd == 0L, , i != 0L),
bor3(pvd == 0L, , i != 0L))
expect_equal(or3s(pve == 1L, , a != 1L),
bor3(pve == 1L, , a != 1L))
expect_equal(or3s(pvf == 9L, , h != 9L),
bor3(pvf == 9L, , h != 9L))
expect_equal(or3s(pvg == 0L, g %between% c(-1L, 1L), ),
bor3(pvg == 0L, g %between% c(-1L, 1L), ))
expect_equal(or3s(pvh == 1L, j %between% c(-1L, 1L), ),
bor3(pvh == 1L, j %between% c(-1L, 1L), ))
expect_equal(or3s(pvi == 9L, v %between% c(-1L, 1L), ),
bor3(pvi == 9L, v %between% c(-1L, 1L), ))
expect_equal(or3s(pvj == 0L, o %between% c(-1L, 1L), f != 0L),
bor3(pvj == 0L, o %between% c(-1L, 1L), f != 0L))
expect_equal(or3s(pvk == 1L, o %between% c(-1L, 1L), t != 1L),
bor3(pvk == 1L, o %between% c(-1L, 1L), t != 1L))
expect_equal(or3s(pvl == 9L, u %between% c(-1L, 1L), t != 9L),
bor3(pvl == 9L, u %between% c(-1L, 1L), t != 9L))
expect_equal(or3s(pvm == 0L, , ),
bor3(pvm == 0L, , ))
expect_equal(or3s(pvn == 1L, , ),
bor3(pvn == 1L, , ))
expect_equal(or3s(pvo == 9L, , ),
bor3(pvo == 9L, , ))
expect_equal(or3s(pvp == 0L, , u %between% c(-1L, 1L)),
bor3(pvp == 0L, , u %between% c(-1L, 1L)))
expect_equal(or3s(pvq == 1L, , t %between% c(-1L, 1L)),
bor3(pvq == 1L, , t %between% c(-1L, 1L)))
expect_equal(or3s(pvr == 9L, , n %between% c(-1L, 1L)),
bor3(pvr == 9L, , n %between% c(-1L, 1L)))
expect_equal(or3s(pvs == 0L, u %between% c(-1L, 1L), ),
bor3(pvs == 0L, u %between% c(-1L, 1L), ))
expect_equal(or3s(pvt == 1L, y %between% c(-1L, 1L), ),
bor3(pvt == 1L, y %between% c(-1L, 1L), ))
expect_equal(or3s(pvu == 9L, s %between% c(-1L, 1L), ),
bor3(pvu == 9L, s %between% c(-1L, 1L), ))
expect_equal(or3s(pvv == 0L, w %between% c(-1L, 1L), i %between% c(-1L, 1L)),
bor3(pvv == 0L, w %between% c(-1L, 1L), i %between% c(-1L, 1L)))
expect_equal(or3s(pvw == 1L, i %between% c(-1L, 1L), m %between% c(-1L, 1L)),
bor3(pvw == 1L, i %between% c(-1L, 1L), m %between% c(-1L, 1L)))
expect_equal(or3s(pvx == 9L, m %between% c(-1L, 1L), j %between% c(-1L, 1L)),
bor3(pvx == 9L, m %between% c(-1L, 1L), j %between% c(-1L, 1L)))
expect_equal(or3s(pvy == 0L, , ),
bor3(pvy == 0L, , ))
expect_equal(or3s(pvz == 1L, , ),
bor3(pvz == 1L, , ))
expect_equal(or3s(pwa == 9L, , ),
bor3(pwa == 9L, , ))
expect_equal(or3s(pwb == 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pwb == 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pwc == 1L, , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pwc == 1L, , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pwd == 9L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pwd == 9L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pwe == 0L, z %between% c(-1L, 1L), ),
bor3(pwe == 0L, z %between% c(-1L, 1L), ))
expect_equal(or3s(pwf == 1L, g %between% c(-1L, 1L), ),
bor3(pwf == 1L, g %between% c(-1L, 1L), ))
expect_equal(or3s(pwg == 9L, i %between% c(-1L, 1L), ),
bor3(pwg == 9L, i %between% c(-1L, 1L), ))
expect_equal(or3s(pwh == 0L, m %between% c(-1L, 1L), e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pwh == 0L, m %between% c(-1L, 1L), e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pwi == 1L, a %between% c(-1L, 1L), x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pwi == 1L, a %between% c(-1L, 1L), x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pwj == 9L, i %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(pwj == 9L, i %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(pwk == 0L, , ),
bor3(pwk == 0L, , ))
expect_equal(or3s(pwl == 1L, , ),
bor3(pwl == 1L, , ))
expect_equal(or3s(pwm == 9L, , ),
bor3(pwm == 9L, , ))
expect_equal(or3s(pwn == 0L, , d %in% 1:4),
bor3(pwn == 0L, , d %in% 1:4))
expect_equal(or3s(pwo == 1L, , i %in% 1:4),
bor3(pwo == 1L, , i %in% 1:4))
expect_equal(or3s(pwp == 9L, , z %in% 1:4),
bor3(pwp == 9L, , z %in% 1:4))
expect_equal(or3s(pwq == 0L, q %between% c(-1L, 1L), ),
bor3(pwq == 0L, q %between% c(-1L, 1L), ))
expect_equal(or3s(pwr == 1L, d %between% c(-1L, 1L), ),
bor3(pwr == 1L, d %between% c(-1L, 1L), ))
expect_equal(or3s(pws == 9L, s %between% c(-1L, 1L), ),
bor3(pws == 9L, s %between% c(-1L, 1L), ))
expect_equal(or3s(pwt == 0L, t %between% c(-1L, 1L), l %in% 1:4),
bor3(pwt == 0L, t %between% c(-1L, 1L), l %in% 1:4))
expect_equal(or3s(pwu == 1L, x %between% c(-1L, 1L), i %in% 1:4),
bor3(pwu == 1L, x %between% c(-1L, 1L), i %in% 1:4))
expect_equal(or3s(pwv == 9L, t %between% c(-1L, 1L), w %in% 1:4),
bor3(pwv == 9L, t %between% c(-1L, 1L), w %in% 1:4))
expect_equal(or3s(pww == 0L, , ),
bor3(pww == 0L, , ))
expect_equal(or3s(pwx == 1L, , ),
bor3(pwx == 1L, , ))
expect_equal(or3s(pwy == 9L, , ),
bor3(pwy == 9L, , ))
expect_equal(or3s(pwz == 0L, , m < 0L),
bor3(pwz == 0L, , m < 0L))
expect_equal(or3s(pxa == 1L, , h < 1L),
bor3(pxa == 1L, , h < 1L))
expect_equal(or3s(pxb == 9L, , l < 9L),
bor3(pxb == 9L, , l < 9L))
expect_equal(or3s(pxc == 0L, b %between% c(-1L, 1L), ),
bor3(pxc == 0L, b %between% c(-1L, 1L), ))
expect_equal(or3s(pxd == 1L, p %between% c(-1L, 1L), ),
bor3(pxd == 1L, p %between% c(-1L, 1L), ))
expect_equal(or3s(pxe == 9L, n %between% c(-1L, 1L), ),
bor3(pxe == 9L, n %between% c(-1L, 1L), ))
expect_equal(or3s(pxf == 0L, a %between% c(-1L, 1L), e < 0L),
bor3(pxf == 0L, a %between% c(-1L, 1L), e < 0L))
expect_equal(or3s(pxg == 1L, j %between% c(-1L, 1L), a < 1L),
bor3(pxg == 1L, j %between% c(-1L, 1L), a < 1L))
expect_equal(or3s(pxh == 9L, h %between% c(-1L, 1L), x < 9L),
bor3(pxh == 9L, h %between% c(-1L, 1L), x < 9L))
expect_equal(or3s(pxi == 0L, , ),
bor3(pxi == 0L, , ))
expect_equal(or3s(pxj == 1L, , ),
bor3(pxj == 1L, , ))
expect_equal(or3s(pxk == 9L, , ),
bor3(pxk == 9L, , ))
expect_equal(or3s(pxl == 0L, , f <= 0L),
bor3(pxl == 0L, , f <= 0L))
expect_equal(or3s(pxm == 1L, , o <= 1L),
bor3(pxm == 1L, , o <= 1L))
expect_equal(or3s(pxn == 9L, , g <= 9L),
bor3(pxn == 9L, , g <= 9L))
expect_equal(or3s(pxo == 0L, z %between% c(-1L, 1L), ),
bor3(pxo == 0L, z %between% c(-1L, 1L), ))
expect_equal(or3s(pxp == 1L, b %between% c(-1L, 1L), ),
bor3(pxp == 1L, b %between% c(-1L, 1L), ))
expect_equal(or3s(pxq == 9L, y %between% c(-1L, 1L), ),
bor3(pxq == 9L, y %between% c(-1L, 1L), ))
expect_equal(or3s(pxr == 0L, o %between% c(-1L, 1L), r <= 0L),
bor3(pxr == 0L, o %between% c(-1L, 1L), r <= 0L))
expect_equal(or3s(pxs == 1L, y %between% c(-1L, 1L), j <= 1L),
bor3(pxs == 1L, y %between% c(-1L, 1L), j <= 1L))
expect_equal(or3s(pxt == 9L, i %between% c(-1L, 1L), g <= 9L),
bor3(pxt == 9L, i %between% c(-1L, 1L), g <= 9L))
expect_equal(or3s(pxu == 0L, , ),
bor3(pxu == 0L, , ))
expect_equal(or3s(pxv == 1L, , ),
bor3(pxv == 1L, , ))
expect_equal(or3s(pxw == 9L, , ),
bor3(pxw == 9L, , ))
expect_equal(or3s(pxx == 0L, , n == 0L),
bor3(pxx == 0L, , n == 0L))
expect_equal(or3s(pxy == 1L, , z == 1L),
bor3(pxy == 1L, , z == 1L))
expect_equal(or3s(pxz == 9L, , d == 9L),
bor3(pxz == 9L, , d == 9L))
expect_equal(or3s(pya == 0L, h %between% c(-1L, 1L), ),
bor3(pya == 0L, h %between% c(-1L, 1L), ))
expect_equal(or3s(pyb == 1L, p %between% c(-1L, 1L), ),
bor3(pyb == 1L, p %between% c(-1L, 1L), ))
expect_equal(or3s(pyc == 9L, b %between% c(-1L, 1L), ),
bor3(pyc == 9L, b %between% c(-1L, 1L), ))
expect_equal(or3s(pyd == 0L, w %between% c(-1L, 1L), f == 0L),
bor3(pyd == 0L, w %between% c(-1L, 1L), f == 0L))
expect_equal(or3s(pye == 1L, c %between% c(-1L, 1L), i == 1L),
bor3(pye == 1L, c %between% c(-1L, 1L), i == 1L))
expect_equal(or3s(pyf == 9L, c %between% c(-1L, 1L), h == 9L),
bor3(pyf == 9L, c %between% c(-1L, 1L), h == 9L))
expect_equal(or3s(pyg == 0L, , ),
bor3(pyg == 0L, , ))
expect_equal(or3s(pyh == 1L, , ),
bor3(pyh == 1L, , ))
expect_equal(or3s(pyi == 9L, , ),
bor3(pyi == 9L, , ))
expect_equal(or3s(pyj == 0L, , j > 0L),
bor3(pyj == 0L, , j > 0L))
expect_equal(or3s(pyk == 1L, , t > 1L),
bor3(pyk == 1L, , t > 1L))
expect_equal(or3s(pyl == 9L, , q > 9L),
bor3(pyl == 9L, , q > 9L))
expect_equal(or3s(pym == 0L, r %between% c(-1L, 1L), ),
bor3(pym == 0L, r %between% c(-1L, 1L), ))
expect_equal(or3s(pyn == 1L, s %between% c(-1L, 1L), ),
bor3(pyn == 1L, s %between% c(-1L, 1L), ))
expect_equal(or3s(pyo == 9L, n %between% c(-1L, 1L), ),
bor3(pyo == 9L, n %between% c(-1L, 1L), ))
expect_equal(or3s(pyp == 0L, q %between% c(-1L, 1L), z > 0L),
bor3(pyp == 0L, q %between% c(-1L, 1L), z > 0L))
expect_equal(or3s(pyq == 1L, n %between% c(-1L, 1L), d > 1L),
bor3(pyq == 1L, n %between% c(-1L, 1L), d > 1L))
expect_equal(or3s(pyr == 9L, h %between% c(-1L, 1L), u > 9L),
bor3(pyr == 9L, h %between% c(-1L, 1L), u > 9L))
expect_equal(or3s(pys == 0L, , ),
bor3(pys == 0L, , ))
expect_equal(or3s(pyt == 1L, , ),
bor3(pyt == 1L, , ))
expect_equal(or3s(pyu == 9L, , ),
bor3(pyu == 9L, , ))
expect_equal(or3s(pyv == 0L, , k >= 0L),
bor3(pyv == 0L, , k >= 0L))
expect_equal(or3s(pyw == 1L, , g >= 1L),
bor3(pyw == 1L, , g >= 1L))
expect_equal(or3s(pyx == 9L, , z >= 9L),
bor3(pyx == 9L, , z >= 9L))
expect_equal(or3s(pyy == 0L, t %between% c(-1L, 1L), ),
bor3(pyy == 0L, t %between% c(-1L, 1L), ))
expect_equal(or3s(pyz == 1L, v %between% c(-1L, 1L), ),
bor3(pyz == 1L, v %between% c(-1L, 1L), ))
expect_equal(or3s(qa == 9L, s %between% c(-1L, 1L), ),
bor3(qa == 9L, s %between% c(-1L, 1L), ))
expect_equal(or3s(qb == 0L, y %between% c(-1L, 1L), r >= 0L),
bor3(qb == 0L, y %between% c(-1L, 1L), r >= 0L))
expect_equal(or3s(qc == 1L, z %between% c(-1L, 1L), u >= 1L),
bor3(qc == 1L, z %between% c(-1L, 1L), u >= 1L))
expect_equal(or3s(qd == 9L, z %between% c(-1L, 1L), j >= 9L),
bor3(qd == 9L, z %between% c(-1L, 1L), j >= 9L))
expect_equal(or3s(qe == 0L, , ),
bor3(qe == 0L, , ))
expect_equal(or3s(qf == 1L, , ),
bor3(qf == 1L, , ))
expect_equal(or3s(qg == 9L, , ),
bor3(qg == 9L, , ))
expect_equal(or3s(qh == 0L, , logi_u),
bor3(qh == 0L, , logi_u))
expect_equal(or3s(qi == 1L, , logi_r),
bor3(qi == 1L, , logi_r))
expect_equal(or3s(qj == 9L, , logi_u),
bor3(qj == 9L, , logi_u))
expect_equal(or3s(qk == 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qk == 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ql == 1L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ql == 1L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qm == 9L, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qm == 9L, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qn == 0L, d %in% c(4L, -3L, 2L, 7L, 8L), logi_o),
bor3(qn == 0L, d %in% c(4L, -3L, 2L, 7L, 8L), logi_o))
expect_equal(or3s(qo == 1L, d %in% c(4L, -3L, 2L, 7L, 8L), logi_z),
bor3(qo == 1L, d %in% c(4L, -3L, 2L, 7L, 8L), logi_z))
expect_equal(or3s(qp == 9L, e %in% c(4L, -3L, 2L, 7L, 8L), logi_f),
bor3(qp == 9L, e %in% c(4L, -3L, 2L, 7L, 8L), logi_f))
expect_equal(or3s(qq == 0L, , ),
bor3(qq == 0L, , ))
expect_equal(or3s(qr == 1L, , ),
bor3(qr == 1L, , ))
expect_equal(or3s(qs == 9L, , ),
bor3(qs == 9L, , ))
expect_equal(or3s(qt == 0L, , logi_q),
bor3(qt == 0L, , logi_q))
expect_equal(or3s(qu == 1L, , logi_j),
bor3(qu == 1L, , logi_j))
expect_equal(or3s(qv == 9L, , logi_m),
bor3(qv == 9L, , logi_m))
expect_equal(or3s(qw == 0L, h %in% 1:4, ),
bor3(qw == 0L, h %in% 1:4, ))
expect_equal(or3s(qx == 1L, q %in% 1:4, ),
bor3(qx == 1L, q %in% 1:4, ))
expect_equal(or3s(qy == 9L, p %in% 1:4, ),
bor3(qy == 9L, p %in% 1:4, ))
expect_equal(or3s(qz == 0L, l %in% 1:4, logi_r),
bor3(qz == 0L, l %in% 1:4, logi_r))
expect_equal(or3s(qaa == 1L, f %in% 1:4, logi_i),
bor3(qaa == 1L, f %in% 1:4, logi_i))
expect_equal(or3s(qab == 9L, r %in% 1:4, logi_n),
bor3(qab == 9L, r %in% 1:4, logi_n))
expect_equal(or3s(qac == 0L, , ),
bor3(qac == 0L, , ))
expect_equal(or3s(qad == 1L, , ),
bor3(qad == 1L, , ))
expect_equal(or3s(qae == 9L, , ),
bor3(qae == 9L, , ))
expect_equal(or3s(qaf == 0L, , !logi_b),
bor3(qaf == 0L, , !logi_b))
expect_equal(or3s(qag == 1L, , !logi_a),
bor3(qag == 1L, , !logi_a))
expect_equal(or3s(qah == 9L, , !logi_j),
bor3(qah == 9L, , !logi_j))
expect_equal(or3s(qai == 0L, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qai == 0L, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qaj == 1L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qaj == 1L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qak == 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qak == 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qal == 0L, g %in% c(4L, -3L, 2L, 7L, 8L), !logi_q),
bor3(qal == 0L, g %in% c(4L, -3L, 2L, 7L, 8L), !logi_q))
expect_equal(or3s(qam == 1L, l %in% c(4L, -3L, 2L, 7L, 8L), !logi_q),
bor3(qam == 1L, l %in% c(4L, -3L, 2L, 7L, 8L), !logi_q))
expect_equal(or3s(qan == 9L, z %in% c(4L, -3L, 2L, 7L, 8L), !logi_q),
bor3(qan == 9L, z %in% c(4L, -3L, 2L, 7L, 8L), !logi_q))
expect_equal(or3s(qao == 0L, , ),
bor3(qao == 0L, , ))
expect_equal(or3s(qap == 1L, , ),
bor3(qap == 1L, , ))
expect_equal(or3s(qaq == 9L, , ),
bor3(qaq == 9L, , ))
expect_equal(or3s(qar == 0L, , !logi_z),
bor3(qar == 0L, , !logi_z))
expect_equal(or3s(qas == 1L, , !logi_s),
bor3(qas == 1L, , !logi_s))
expect_equal(or3s(qat == 9L, , !logi_t),
bor3(qat == 9L, , !logi_t))
expect_equal(or3s(qau == 0L, c %in% 1:4, ),
bor3(qau == 0L, c %in% 1:4, ))
expect_equal(or3s(qav == 1L, d %in% 1:4, ),
bor3(qav == 1L, d %in% 1:4, ))
expect_equal(or3s(qaw == 9L, e %in% 1:4, ),
bor3(qaw == 9L, e %in% 1:4, ))
expect_equal(or3s(qax == 0L, h %in% 1:4, !logi_l),
bor3(qax == 0L, h %in% 1:4, !logi_l))
expect_equal(or3s(qay == 1L, w %in% 1:4, !logi_l),
bor3(qay == 1L, w %in% 1:4, !logi_l))
expect_equal(or3s(qaz == 9L, x %in% 1:4, !logi_k),
bor3(qaz == 9L, x %in% 1:4, !logi_k))
expect_equal(or3s(qba == 0L, , ),
bor3(qba == 0L, , ))
expect_equal(or3s(qbb == 1L, , ),
bor3(qbb == 1L, , ))
expect_equal(or3s(qbc == 9L, , ),
bor3(qbc == 9L, , ))
expect_equal(or3s(qbd == 0L, , x != 0L),
bor3(qbd == 0L, , x != 0L))
expect_equal(or3s(qbe == 1L, , u != 1L),
bor3(qbe == 1L, , u != 1L))
expect_equal(or3s(qbf == 9L, , w != 9L),
bor3(qbf == 9L, , w != 9L))
expect_equal(or3s(qbg == 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qbg == 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qbh == 1L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qbh == 1L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qbi == 9L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qbi == 9L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qbj == 0L, n %in% c(4L, -3L, 2L, 7L, 8L), y != 0L),
bor3(qbj == 0L, n %in% c(4L, -3L, 2L, 7L, 8L), y != 0L))
expect_equal(or3s(qbk == 1L, t %in% c(4L, -3L, 2L, 7L, 8L), r != 1L),
bor3(qbk == 1L, t %in% c(4L, -3L, 2L, 7L, 8L), r != 1L))
expect_equal(or3s(qbl == 9L, x %in% c(4L, -3L, 2L, 7L, 8L), v != 9L),
bor3(qbl == 9L, x %in% c(4L, -3L, 2L, 7L, 8L), v != 9L))
expect_equal(or3s(qbm == 0L, , ),
bor3(qbm == 0L, , ))
expect_equal(or3s(qbn == 1L, , ),
bor3(qbn == 1L, , ))
expect_equal(or3s(qbo == 9L, , ),
bor3(qbo == 9L, , ))
expect_equal(or3s(qbp == 0L, , f != 0L),
bor3(qbp == 0L, , f != 0L))
expect_equal(or3s(qbq == 1L, , e != 1L),
bor3(qbq == 1L, , e != 1L))
expect_equal(or3s(qbr == 9L, , n != 9L),
bor3(qbr == 9L, , n != 9L))
expect_equal(or3s(qbs == 0L, j %in% 1:4, ),
bor3(qbs == 0L, j %in% 1:4, ))
expect_equal(or3s(qbt == 1L, h %in% 1:4, ),
bor3(qbt == 1L, h %in% 1:4, ))
expect_equal(or3s(qbu == 9L, l %in% 1:4, ),
bor3(qbu == 9L, l %in% 1:4, ))
expect_equal(or3s(qbv == 0L, u %in% 1:4, l != 0L),
bor3(qbv == 0L, u %in% 1:4, l != 0L))
expect_equal(or3s(qbw == 1L, r %in% 1:4, x != 1L),
bor3(qbw == 1L, r %in% 1:4, x != 1L))
expect_equal(or3s(qbx == 9L, r %in% 1:4, f != 9L),
bor3(qbx == 9L, r %in% 1:4, f != 9L))
expect_equal(or3s(qby == 0L, , ),
bor3(qby == 0L, , ))
expect_equal(or3s(qbz == 1L, , ),
bor3(qbz == 1L, , ))
expect_equal(or3s(qca == 9L, , ),
bor3(qca == 9L, , ))
expect_equal(or3s(qcb == 0L, , m %between% c(-1L, 1L)),
bor3(qcb == 0L, , m %between% c(-1L, 1L)))
expect_equal(or3s(qcc == 1L, , r %between% c(-1L, 1L)),
bor3(qcc == 1L, , r %between% c(-1L, 1L)))
expect_equal(or3s(qcd == 9L, , g %between% c(-1L, 1L)),
bor3(qcd == 9L, , g %between% c(-1L, 1L)))
expect_equal(or3s(qce == 0L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qce == 0L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qcf == 1L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qcf == 1L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qcg == 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qcg == 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qch == 0L, g %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)),
bor3(qch == 0L, g %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)))
expect_equal(or3s(qci == 1L, o %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)),
bor3(qci == 1L, o %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)))
expect_equal(or3s(qcj == 9L, h %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L)),
bor3(qcj == 9L, h %in% c(4L, -3L, 2L, 7L, 8L), e %between% c(-1L, 1L)))
expect_equal(or3s(qck == 0L, , ),
bor3(qck == 0L, , ))
expect_equal(or3s(qcl == 1L, , ),
bor3(qcl == 1L, , ))
expect_equal(or3s(qcm == 9L, , ),
bor3(qcm == 9L, , ))
expect_equal(or3s(qcn == 0L, , v %between% c(-1L, 1L)),
bor3(qcn == 0L, , v %between% c(-1L, 1L)))
expect_equal(or3s(qco == 1L, , y %between% c(-1L, 1L)),
bor3(qco == 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(qcp == 9L, , k %between% c(-1L, 1L)),
bor3(qcp == 9L, , k %between% c(-1L, 1L)))
expect_equal(or3s(qcq == 0L, g %in% 1:4, ),
bor3(qcq == 0L, g %in% 1:4, ))
expect_equal(or3s(qcr == 1L, b %in% 1:4, ),
bor3(qcr == 1L, b %in% 1:4, ))
expect_equal(or3s(qcs == 9L, q %in% 1:4, ),
bor3(qcs == 9L, q %in% 1:4, ))
expect_equal(or3s(qct == 0L, y %in% 1:4, q %between% c(-1L, 1L)),
bor3(qct == 0L, y %in% 1:4, q %between% c(-1L, 1L)))
expect_equal(or3s(qcu == 1L, o %in% 1:4, y %between% c(-1L, 1L)),
bor3(qcu == 1L, o %in% 1:4, y %between% c(-1L, 1L)))
expect_equal(or3s(qcv == 9L, k %in% 1:4, j %between% c(-1L, 1L)),
bor3(qcv == 9L, k %in% 1:4, j %between% c(-1L, 1L)))
expect_equal(or3s(qcw == 0L, , ),
bor3(qcw == 0L, , ))
expect_equal(or3s(qcx == 1L, , ),
bor3(qcx == 1L, , ))
expect_equal(or3s(qcy == 9L, , ),
bor3(qcy == 9L, , ))
expect_equal(or3s(qcz == 0L, , o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qcz == 0L, , o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qda == 1L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qda == 1L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qdb == 9L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qdb == 9L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qdc == 0L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qdc == 0L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qdd == 1L, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qdd == 1L, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qde == 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qde == 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qdf == 0L, v %in% c(4L, -3L, 2L, 7L, 8L), d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qdf == 0L, v %in% c(4L, -3L, 2L, 7L, 8L), d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qdg == 1L, w %in% c(4L, -3L, 2L, 7L, 8L), o %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qdg == 1L, w %in% c(4L, -3L, 2L, 7L, 8L), o %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qdh == 9L, e %in% c(4L, -3L, 2L, 7L, 8L), b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qdh == 9L, e %in% c(4L, -3L, 2L, 7L, 8L), b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qdi == 0L, , ),
bor3(qdi == 0L, , ))
expect_equal(or3s(qdj == 1L, , ),
bor3(qdj == 1L, , ))
expect_equal(or3s(qdk == 9L, , ),
bor3(qdk == 9L, , ))
expect_equal(or3s(qdl == 0L, , l %in% 1:4),
bor3(qdl == 0L, , l %in% 1:4))
expect_equal(or3s(qdm == 1L, , o %in% 1:4),
bor3(qdm == 1L, , o %in% 1:4))
expect_equal(or3s(qdn == 9L, , b %in% 1:4),
bor3(qdn == 9L, , b %in% 1:4))
expect_equal(or3s(qdo == 0L, j %in% 1:4, ),
bor3(qdo == 0L, j %in% 1:4, ))
expect_equal(or3s(qdp == 1L, r %in% 1:4, ),
bor3(qdp == 1L, r %in% 1:4, ))
expect_equal(or3s(qdq == 9L, f %in% 1:4, ),
bor3(qdq == 9L, f %in% 1:4, ))
expect_equal(or3s(qdr == 0L, k %in% 1:4, w %in% 1:4),
bor3(qdr == 0L, k %in% 1:4, w %in% 1:4))
expect_equal(or3s(qds == 1L, a %in% 1:4, d %in% 1:4),
bor3(qds == 1L, a %in% 1:4, d %in% 1:4))
expect_equal(or3s(qdt == 9L, e %in% 1:4, q %in% 1:4),
bor3(qdt == 9L, e %in% 1:4, q %in% 1:4))
expect_equal(or3s(qdu == 0L, , ),
bor3(qdu == 0L, , ))
expect_equal(or3s(qdv == 1L, , ),
bor3(qdv == 1L, , ))
expect_equal(or3s(qdw == 9L, , ),
bor3(qdw == 9L, , ))
expect_equal(or3s(qdx == 0L, , z < 0L),
bor3(qdx == 0L, , z < 0L))
expect_equal(or3s(qdy == 1L, , c < 1L),
bor3(qdy == 1L, , c < 1L))
expect_equal(or3s(qdz == 9L, , n < 9L),
bor3(qdz == 9L, , n < 9L))
expect_equal(or3s(qea == 0L, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qea == 0L, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qeb == 1L, x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qeb == 1L, x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qec == 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qec == 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qed == 0L, m %in% c(4L, -3L, 2L, 7L, 8L), f < 0L),
bor3(qed == 0L, m %in% c(4L, -3L, 2L, 7L, 8L), f < 0L))
expect_equal(or3s(qee == 1L, x %in% c(4L, -3L, 2L, 7L, 8L), o < 1L),
bor3(qee == 1L, x %in% c(4L, -3L, 2L, 7L, 8L), o < 1L))
expect_equal(or3s(qef == 9L, f %in% c(4L, -3L, 2L, 7L, 8L), c < 9L),
bor3(qef == 9L, f %in% c(4L, -3L, 2L, 7L, 8L), c < 9L))
expect_equal(or3s(qeg == 0L, , ),
bor3(qeg == 0L, , ))
expect_equal(or3s(qeh == 1L, , ),
bor3(qeh == 1L, , ))
expect_equal(or3s(qei == 9L, , ),
bor3(qei == 9L, , ))
expect_equal(or3s(qej == 0L, , d < 0L),
bor3(qej == 0L, , d < 0L))
expect_equal(or3s(qek == 1L, , a < 1L),
bor3(qek == 1L, , a < 1L))
expect_equal(or3s(qel == 9L, , l < 9L),
bor3(qel == 9L, , l < 9L))
expect_equal(or3s(qem == 0L, q %in% 1:4, ),
bor3(qem == 0L, q %in% 1:4, ))
expect_equal(or3s(qen == 1L, l %in% 1:4, ),
bor3(qen == 1L, l %in% 1:4, ))
expect_equal(or3s(qeo == 9L, b %in% 1:4, ),
bor3(qeo == 9L, b %in% 1:4, ))
expect_equal(or3s(qep == 0L, h %in% 1:4, u < 0L),
bor3(qep == 0L, h %in% 1:4, u < 0L))
expect_equal(or3s(qeq == 1L, d %in% 1:4, d < 1L),
bor3(qeq == 1L, d %in% 1:4, d < 1L))
expect_equal(or3s(qer == 9L, s %in% 1:4, j < 9L),
bor3(qer == 9L, s %in% 1:4, j < 9L))
expect_equal(or3s(qes == 0L, , ),
bor3(qes == 0L, , ))
expect_equal(or3s(qet == 1L, , ),
bor3(qet == 1L, , ))
expect_equal(or3s(qeu == 9L, , ),
bor3(qeu == 9L, , ))
expect_equal(or3s(qev == 0L, , m <= 0L),
bor3(qev == 0L, , m <= 0L))
expect_equal(or3s(qew == 1L, , i <= 1L),
bor3(qew == 1L, , i <= 1L))
expect_equal(or3s(qex == 9L, , g <= 9L),
bor3(qex == 9L, , g <= 9L))
expect_equal(or3s(qey == 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qey == 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qez == 1L, a %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qez == 1L, a %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qfa == 9L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qfa == 9L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qfb == 0L, g %in% c(4L, -3L, 2L, 7L, 8L), q <= 0L),
bor3(qfb == 0L, g %in% c(4L, -3L, 2L, 7L, 8L), q <= 0L))
expect_equal(or3s(qfc == 1L, k %in% c(4L, -3L, 2L, 7L, 8L), d <= 1L),
bor3(qfc == 1L, k %in% c(4L, -3L, 2L, 7L, 8L), d <= 1L))
expect_equal(or3s(qfd == 9L, n %in% c(4L, -3L, 2L, 7L, 8L), k <= 9L),
bor3(qfd == 9L, n %in% c(4L, -3L, 2L, 7L, 8L), k <= 9L))
expect_equal(or3s(qfe == 0L, , ),
bor3(qfe == 0L, , ))
expect_equal(or3s(qff == 1L, , ),
bor3(qff == 1L, , ))
expect_equal(or3s(qfg == 9L, , ),
bor3(qfg == 9L, , ))
expect_equal(or3s(qfh == 0L, , n <= 0L),
bor3(qfh == 0L, , n <= 0L))
expect_equal(or3s(qfi == 1L, , y <= 1L),
bor3(qfi == 1L, , y <= 1L))
expect_equal(or3s(qfj == 9L, , c <= 9L),
bor3(qfj == 9L, , c <= 9L))
expect_equal(or3s(qfk == 0L, o %in% 1:4, ),
bor3(qfk == 0L, o %in% 1:4, ))
expect_equal(or3s(qfl == 1L, m %in% 1:4, ),
bor3(qfl == 1L, m %in% 1:4, ))
expect_equal(or3s(qfm == 9L, i %in% 1:4, ),
bor3(qfm == 9L, i %in% 1:4, ))
expect_equal(or3s(qfn == 0L, f %in% 1:4, o <= 0L),
bor3(qfn == 0L, f %in% 1:4, o <= 0L))
expect_equal(or3s(qfo == 1L, z %in% 1:4, k <= 1L),
bor3(qfo == 1L, z %in% 1:4, k <= 1L))
expect_equal(or3s(qfp == 9L, s %in% 1:4, m <= 9L),
bor3(qfp == 9L, s %in% 1:4, m <= 9L))
expect_equal(or3s(qfq == 0L, , ),
bor3(qfq == 0L, , ))
expect_equal(or3s(qfr == 1L, , ),
bor3(qfr == 1L, , ))
expect_equal(or3s(qfs == 9L, , ),
bor3(qfs == 9L, , ))
expect_equal(or3s(qft == 0L, , d == 0L),
bor3(qft == 0L, , d == 0L))
expect_equal(or3s(qfu == 1L, , z == 1L),
bor3(qfu == 1L, , z == 1L))
expect_equal(or3s(qfv == 9L, , c == 9L),
bor3(qfv == 9L, , c == 9L))
expect_equal(or3s(qfw == 0L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qfw == 0L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qfx == 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qfx == 1L, t %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qfy == 9L, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qfy == 9L, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qfz == 0L, c %in% c(4L, -3L, 2L, 7L, 8L), h == 0L),
bor3(qfz == 0L, c %in% c(4L, -3L, 2L, 7L, 8L), h == 0L))
expect_equal(or3s(qga == 1L, z %in% c(4L, -3L, 2L, 7L, 8L), m == 1L),
bor3(qga == 1L, z %in% c(4L, -3L, 2L, 7L, 8L), m == 1L))
expect_equal(or3s(qgb == 9L, y %in% c(4L, -3L, 2L, 7L, 8L), h == 9L),
bor3(qgb == 9L, y %in% c(4L, -3L, 2L, 7L, 8L), h == 9L))
expect_equal(or3s(qgc == 0L, , ),
bor3(qgc == 0L, , ))
expect_equal(or3s(qgd == 1L, , ),
bor3(qgd == 1L, , ))
expect_equal(or3s(qge == 9L, , ),
bor3(qge == 9L, , ))
expect_equal(or3s(qgf == 0L, , f == 0L),
bor3(qgf == 0L, , f == 0L))
expect_equal(or3s(qgg == 1L, , u == 1L),
bor3(qgg == 1L, , u == 1L))
expect_equal(or3s(qgh == 9L, , s == 9L),
bor3(qgh == 9L, , s == 9L))
expect_equal(or3s(qgi == 0L, i %in% 1:4, ),
bor3(qgi == 0L, i %in% 1:4, ))
expect_equal(or3s(qgj == 1L, d %in% 1:4, ),
bor3(qgj == 1L, d %in% 1:4, ))
expect_equal(or3s(qgk == 9L, m %in% 1:4, ),
bor3(qgk == 9L, m %in% 1:4, ))
expect_equal(or3s(qgl == 0L, o %in% 1:4, e == 0L),
bor3(qgl == 0L, o %in% 1:4, e == 0L))
expect_equal(or3s(qgm == 1L, w %in% 1:4, c == 1L),
bor3(qgm == 1L, w %in% 1:4, c == 1L))
expect_equal(or3s(qgn == 9L, i %in% 1:4, e == 9L),
bor3(qgn == 9L, i %in% 1:4, e == 9L))
expect_equal(or3s(qgo == 0L, , ),
bor3(qgo == 0L, , ))
expect_equal(or3s(qgp == 1L, , ),
bor3(qgp == 1L, , ))
expect_equal(or3s(qgq == 9L, , ),
bor3(qgq == 9L, , ))
expect_equal(or3s(qgr == 0L, , v > 0L),
bor3(qgr == 0L, , v > 0L))
expect_equal(or3s(qgs == 1L, , x > 1L),
bor3(qgs == 1L, , x > 1L))
expect_equal(or3s(qgt == 9L, , k > 9L),
bor3(qgt == 9L, , k > 9L))
expect_equal(or3s(qgu == 0L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qgu == 0L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qgv == 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qgv == 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qgw == 9L, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qgw == 9L, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qgx == 0L, m %in% c(4L, -3L, 2L, 7L, 8L), k > 0L),
bor3(qgx == 0L, m %in% c(4L, -3L, 2L, 7L, 8L), k > 0L))
expect_equal(or3s(qgy == 1L, p %in% c(4L, -3L, 2L, 7L, 8L), y > 1L),
bor3(qgy == 1L, p %in% c(4L, -3L, 2L, 7L, 8L), y > 1L))
expect_equal(or3s(qgz == 9L, w %in% c(4L, -3L, 2L, 7L, 8L), z > 9L),
bor3(qgz == 9L, w %in% c(4L, -3L, 2L, 7L, 8L), z > 9L))
expect_equal(or3s(qha == 0L, , ),
bor3(qha == 0L, , ))
expect_equal(or3s(qhb == 1L, , ),
bor3(qhb == 1L, , ))
expect_equal(or3s(qhc == 9L, , ),
bor3(qhc == 9L, , ))
expect_equal(or3s(qhd == 0L, , m > 0L),
bor3(qhd == 0L, , m > 0L))
expect_equal(or3s(qhe == 1L, , b > 1L),
bor3(qhe == 1L, , b > 1L))
expect_equal(or3s(qhf == 9L, , b > 9L),
bor3(qhf == 9L, , b > 9L))
expect_equal(or3s(qhg == 0L, p %in% 1:4, ),
bor3(qhg == 0L, p %in% 1:4, ))
expect_equal(or3s(qhh == 1L, k %in% 1:4, ),
bor3(qhh == 1L, k %in% 1:4, ))
expect_equal(or3s(qhi == 9L, l %in% 1:4, ),
bor3(qhi == 9L, l %in% 1:4, ))
expect_equal(or3s(qhj == 0L, h %in% 1:4, j > 0L),
bor3(qhj == 0L, h %in% 1:4, j > 0L))
expect_equal(or3s(qhk == 1L, q %in% 1:4, u > 1L),
bor3(qhk == 1L, q %in% 1:4, u > 1L))
expect_equal(or3s(qhl == 9L, y %in% 1:4, q > 9L),
bor3(qhl == 9L, y %in% 1:4, q > 9L))
expect_equal(or3s(qhm == 0L, , ),
bor3(qhm == 0L, , ))
expect_equal(or3s(qhn == 1L, , ),
bor3(qhn == 1L, , ))
expect_equal(or3s(qho == 9L, , ),
bor3(qho == 9L, , ))
expect_equal(or3s(qhp == 0L, , x >= 0L),
bor3(qhp == 0L, , x >= 0L))
expect_equal(or3s(qhq == 1L, , z >= 1L),
bor3(qhq == 1L, , z >= 1L))
expect_equal(or3s(qhr == 9L, , l >= 9L),
bor3(qhr == 9L, , l >= 9L))
expect_equal(or3s(qhs == 0L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qhs == 0L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qht == 1L, y %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qht == 1L, y %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qhu == 9L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(qhu == 9L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(qhv == 0L, i %in% c(4L, -3L, 2L, 7L, 8L), p >= 0L),
bor3(qhv == 0L, i %in% c(4L, -3L, 2L, 7L, 8L), p >= 0L))
expect_equal(or3s(qhw == 1L, i %in% c(4L, -3L, 2L, 7L, 8L), m >= 1L),
bor3(qhw == 1L, i %in% c(4L, -3L, 2L, 7L, 8L), m >= 1L))
expect_equal(or3s(qhx == 9L, r %in% c(4L, -3L, 2L, 7L, 8L), a >= 9L),
bor3(qhx == 9L, r %in% c(4L, -3L, 2L, 7L, 8L), a >= 9L))
expect_equal(or3s(qhy == 0L, , ),
bor3(qhy == 0L, , ))
expect_equal(or3s(qhz == 1L, , ),
bor3(qhz == 1L, , ))
expect_equal(or3s(qia == 9L, , ),
bor3(qia == 9L, , ))
expect_equal(or3s(qib == 0L, , f >= 0L),
bor3(qib == 0L, , f >= 0L))
expect_equal(or3s(qic == 1L, , h >= 1L),
bor3(qic == 1L, , h >= 1L))
expect_equal(or3s(qid == 9L, , x >= 9L),
bor3(qid == 9L, , x >= 9L))
expect_equal(or3s(qie == 0L, d %in% 1:4, ),
bor3(qie == 0L, d %in% 1:4, ))
expect_equal(or3s(qif == 1L, t %in% 1:4, ),
bor3(qif == 1L, t %in% 1:4, ))
expect_equal(or3s(qig == 9L, s %in% 1:4, ),
bor3(qig == 9L, s %in% 1:4, ))
expect_equal(or3s(qih == 0L, g %in% 1:4, k >= 0L),
bor3(qih == 0L, g %in% 1:4, k >= 0L))
expect_equal(or3s(qii == 1L, g %in% 1:4, q >= 1L),
bor3(qii == 1L, g %in% 1:4, q >= 1L))
expect_equal(or3s(qij == 9L, w %in% 1:4, x >= 9L),
bor3(qij == 9L, w %in% 1:4, x >= 9L))
expect_equal(or3s(qik == 0L, , ),
bor3(qik == 0L, , ))
expect_equal(or3s(qil == 1L, , ),
bor3(qil == 1L, , ))
expect_equal(or3s(qim == 9L, , ),
bor3(qim == 9L, , ))
expect_equal(or3s(qin == 0L, , logi_f),
bor3(qin == 0L, , logi_f))
expect_equal(or3s(qio == 1L, , logi_u),
bor3(qio == 1L, , logi_u))
expect_equal(or3s(qip == 9L, , logi_m),
bor3(qip == 9L, , logi_m))
expect_equal(or3s(qiq == 0L, e < 0L, ),
bor3(qiq == 0L, e < 0L, ))
expect_equal(or3s(qir == 1L, m < 1L, ),
bor3(qir == 1L, m < 1L, ))
expect_equal(or3s(qis == 9L, d < 9L, ),
bor3(qis == 9L, d < 9L, ))
expect_equal(or3s(qit == 0L, z < 0L, logi_x),
bor3(qit == 0L, z < 0L, logi_x))
expect_equal(or3s(qiu == 1L, s < 1L, logi_j),
bor3(qiu == 1L, s < 1L, logi_j))
expect_equal(or3s(qiv == 9L, d < 9L, logi_c),
bor3(qiv == 9L, d < 9L, logi_c))
expect_equal(or3s(qiw == 0L, , ),
bor3(qiw == 0L, , ))
expect_equal(or3s(qix == 1L, , ),
bor3(qix == 1L, , ))
expect_equal(or3s(qiy == 9L, , ),
bor3(qiy == 9L, , ))
expect_equal(or3s(qiz == 0L, , !logi_k),
bor3(qiz == 0L, , !logi_k))
expect_equal(or3s(qja == 1L, , !logi_n),
bor3(qja == 1L, , !logi_n))
expect_equal(or3s(qjb == 9L, , !logi_q),
bor3(qjb == 9L, , !logi_q))
expect_equal(or3s(qjc == 0L, p < 0L, ),
bor3(qjc == 0L, p < 0L, ))
expect_equal(or3s(qjd == 1L, o < 1L, ),
bor3(qjd == 1L, o < 1L, ))
expect_equal(or3s(qje == 9L, x < 9L, ),
bor3(qje == 9L, x < 9L, ))
expect_equal(or3s(qjf == 0L, d < 0L, !logi_h),
bor3(qjf == 0L, d < 0L, !logi_h))
expect_equal(or3s(qjg == 1L, t < 1L, !logi_p),
bor3(qjg == 1L, t < 1L, !logi_p))
expect_equal(or3s(qjh == 9L, q < 9L, !logi_d),
bor3(qjh == 9L, q < 9L, !logi_d))
expect_equal(or3s(qji == 0L, , ),
bor3(qji == 0L, , ))
expect_equal(or3s(qjj == 1L, , ),
bor3(qjj == 1L, , ))
expect_equal(or3s(qjk == 9L, , ),
bor3(qjk == 9L, , ))
expect_equal(or3s(qjl == 0L, , s != 0L),
bor3(qjl == 0L, , s != 0L))
expect_equal(or3s(qjm == 1L, , d != 1L),
bor3(qjm == 1L, , d != 1L))
expect_equal(or3s(qjn == 9L, , p != 9L),
bor3(qjn == 9L, , p != 9L))
expect_equal(or3s(qjo == 0L, p < 0L, ),
bor3(qjo == 0L, p < 0L, ))
expect_equal(or3s(qjp == 1L, y < 1L, ),
bor3(qjp == 1L, y < 1L, ))
expect_equal(or3s(qjq == 9L, l < 9L, ),
bor3(qjq == 9L, l < 9L, ))
expect_equal(or3s(qjr == 0L, v < 0L, f != 0L),
bor3(qjr == 0L, v < 0L, f != 0L))
expect_equal(or3s(qjs == 1L, s < 1L, p != 1L),
bor3(qjs == 1L, s < 1L, p != 1L))
expect_equal(or3s(qjt == 9L, x < 9L, r != 9L),
bor3(qjt == 9L, x < 9L, r != 9L))
expect_equal(or3s(qju == 0L, , ),
bor3(qju == 0L, , ))
expect_equal(or3s(qjv == 1L, , ),
bor3(qjv == 1L, , ))
expect_equal(or3s(qjw == 9L, , ),
bor3(qjw == 9L, , ))
expect_equal(or3s(qjx == 0L, , d %between% c(-1L, 1L)),
bor3(qjx == 0L, , d %between% c(-1L, 1L)))
expect_equal(or3s(qjy == 1L, , k %between% c(-1L, 1L)),
bor3(qjy == 1L, , k %between% c(-1L, 1L)))
expect_equal(or3s(qjz == 9L, , a %between% c(-1L, 1L)),
bor3(qjz == 9L, , a %between% c(-1L, 1L)))
expect_equal(or3s(qka == 0L, r < 0L, ),
bor3(qka == 0L, r < 0L, ))
expect_equal(or3s(qkb == 1L, k < 1L, ),
bor3(qkb == 1L, k < 1L, ))
expect_equal(or3s(qkc == 9L, e < 9L, ),
bor3(qkc == 9L, e < 9L, ))
expect_equal(or3s(qkd == 0L, r < 0L, o %between% c(-1L, 1L)),
bor3(qkd == 0L, r < 0L, o %between% c(-1L, 1L)))
expect_equal(or3s(qke == 1L, i < 1L, z %between% c(-1L, 1L)),
bor3(qke == 1L, i < 1L, z %between% c(-1L, 1L)))
expect_equal(or3s(qkf == 9L, t < 9L, j %between% c(-1L, 1L)),
bor3(qkf == 9L, t < 9L, j %between% c(-1L, 1L)))
expect_equal(or3s(qkg == 0L, , ),
bor3(qkg == 0L, , ))
expect_equal(or3s(qkh == 1L, , ),
bor3(qkh == 1L, , ))
expect_equal(or3s(qki == 9L, , ),
bor3(qki == 9L, , ))
expect_equal(or3s(qkj == 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qkj == 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qkk == 1L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qkk == 1L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qkl == 9L, , q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qkl == 9L, , q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qkm == 0L, h < 0L, ),
bor3(qkm == 0L, h < 0L, ))
expect_equal(or3s(qkn == 1L, y < 1L, ),
bor3(qkn == 1L, y < 1L, ))
expect_equal(or3s(qko == 9L, m < 9L, ),
bor3(qko == 9L, m < 9L, ))
expect_equal(or3s(qkp == 0L, g < 0L, l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qkp == 0L, g < 0L, l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qkq == 1L, o < 1L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qkq == 1L, o < 1L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qkr == 9L, s < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qkr == 9L, s < 9L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qks == 0L, , ),
bor3(qks == 0L, , ))
expect_equal(or3s(qkt == 1L, , ),
bor3(qkt == 1L, , ))
expect_equal(or3s(qku == 9L, , ),
bor3(qku == 9L, , ))
expect_equal(or3s(qkv == 0L, , g %in% 1:4),
bor3(qkv == 0L, , g %in% 1:4))
expect_equal(or3s(qkw == 1L, , r %in% 1:4),
bor3(qkw == 1L, , r %in% 1:4))
expect_equal(or3s(qkx == 9L, , f %in% 1:4),
bor3(qkx == 9L, , f %in% 1:4))
expect_equal(or3s(qky == 0L, u < 0L, ),
bor3(qky == 0L, u < 0L, ))
expect_equal(or3s(qkz == 1L, c < 1L, ),
bor3(qkz == 1L, c < 1L, ))
expect_equal(or3s(qla == 9L, o < 9L, ),
bor3(qla == 9L, o < 9L, ))
expect_equal(or3s(qlb == 0L, b < 0L, q %in% 1:4),
bor3(qlb == 0L, b < 0L, q %in% 1:4))
expect_equal(or3s(qlc == 1L, q < 1L, h %in% 1:4),
bor3(qlc == 1L, q < 1L, h %in% 1:4))
expect_equal(or3s(qld == 9L, r < 9L, c %in% 1:4),
bor3(qld == 9L, r < 9L, c %in% 1:4))
expect_equal(or3s(qle == 0L, , ),
bor3(qle == 0L, , ))
expect_equal(or3s(qlf == 1L, , ),
bor3(qlf == 1L, , ))
expect_equal(or3s(qlg == 9L, , ),
bor3(qlg == 9L, , ))
expect_equal(or3s(qlh == 0L, , n < 0L),
bor3(qlh == 0L, , n < 0L))
expect_equal(or3s(qli == 1L, , j < 1L),
bor3(qli == 1L, , j < 1L))
expect_equal(or3s(qlj == 9L, , q < 9L),
bor3(qlj == 9L, , q < 9L))
expect_equal(or3s(qlk == 0L, n < 0L, ),
bor3(qlk == 0L, n < 0L, ))
expect_equal(or3s(qll == 1L, e < 1L, ),
bor3(qll == 1L, e < 1L, ))
expect_equal(or3s(qlm == 9L, z < 9L, ),
bor3(qlm == 9L, z < 9L, ))
expect_equal(or3s(qln == 0L, t < 0L, l < 0L),
bor3(qln == 0L, t < 0L, l < 0L))
expect_equal(or3s(qlo == 1L, g < 1L, c < 1L),
bor3(qlo == 1L, g < 1L, c < 1L))
expect_equal(or3s(qlp == 9L, f < 9L, q < 9L),
bor3(qlp == 9L, f < 9L, q < 9L))
expect_equal(or3s(qlq == 0L, , ),
bor3(qlq == 0L, , ))
expect_equal(or3s(qlr == 1L, , ),
bor3(qlr == 1L, , ))
expect_equal(or3s(qls == 9L, , ),
bor3(qls == 9L, , ))
expect_equal(or3s(qlt == 0L, , u <= 0L),
bor3(qlt == 0L, , u <= 0L))
expect_equal(or3s(qlu == 1L, , o <= 1L),
bor3(qlu == 1L, , o <= 1L))
expect_equal(or3s(qlv == 9L, , n <= 9L),
bor3(qlv == 9L, , n <= 9L))
expect_equal(or3s(qlw == 0L, c < 0L, ),
bor3(qlw == 0L, c < 0L, ))
expect_equal(or3s(qlx == 1L, l < 1L, ),
bor3(qlx == 1L, l < 1L, ))
expect_equal(or3s(qly == 9L, e < 9L, ),
bor3(qly == 9L, e < 9L, ))
expect_equal(or3s(qlz == 0L, o < 0L, m <= 0L),
bor3(qlz == 0L, o < 0L, m <= 0L))
expect_equal(or3s(qma == 1L, c < 1L, m <= 1L),
bor3(qma == 1L, c < 1L, m <= 1L))
expect_equal(or3s(qmb == 9L, m < 9L, v <= 9L),
bor3(qmb == 9L, m < 9L, v <= 9L))
expect_equal(or3s(qmc == 0L, , ),
bor3(qmc == 0L, , ))
expect_equal(or3s(qmd == 1L, , ),
bor3(qmd == 1L, , ))
expect_equal(or3s(qme == 9L, , ),
bor3(qme == 9L, , ))
expect_equal(or3s(qmf == 0L, , v == 0L),
bor3(qmf == 0L, , v == 0L))
expect_equal(or3s(qmg == 1L, , b == 1L),
bor3(qmg == 1L, , b == 1L))
expect_equal(or3s(qmh == 9L, , p == 9L),
bor3(qmh == 9L, , p == 9L))
expect_equal(or3s(qmi == 0L, x < 0L, ),
bor3(qmi == 0L, x < 0L, ))
expect_equal(or3s(qmj == 1L, k < 1L, ),
bor3(qmj == 1L, k < 1L, ))
expect_equal(or3s(qmk == 9L, n < 9L, ),
bor3(qmk == 9L, n < 9L, ))
expect_equal(or3s(qml == 0L, l < 0L, w == 0L),
bor3(qml == 0L, l < 0L, w == 0L))
expect_equal(or3s(qmm == 1L, p < 1L, j == 1L),
bor3(qmm == 1L, p < 1L, j == 1L))
expect_equal(or3s(qmn == 9L, s < 9L, i == 9L),
bor3(qmn == 9L, s < 9L, i == 9L))
expect_equal(or3s(qmo == 0L, , ),
bor3(qmo == 0L, , ))
expect_equal(or3s(qmp == 1L, , ),
bor3(qmp == 1L, , ))
expect_equal(or3s(qmq == 9L, , ),
bor3(qmq == 9L, , ))
expect_equal(or3s(qmr == 0L, , m > 0L),
bor3(qmr == 0L, , m > 0L))
expect_equal(or3s(qms == 1L, , e > 1L),
bor3(qms == 1L, , e > 1L))
expect_equal(or3s(qmt == 9L, , n > 9L),
bor3(qmt == 9L, , n > 9L))
expect_equal(or3s(qmu == 0L, h < 0L, ),
bor3(qmu == 0L, h < 0L, ))
expect_equal(or3s(qmv == 1L, j < 1L, ),
bor3(qmv == 1L, j < 1L, ))
expect_equal(or3s(qmw == 9L, i < 9L, ),
bor3(qmw == 9L, i < 9L, ))
expect_equal(or3s(qmx == 0L, r < 0L, g > 0L),
bor3(qmx == 0L, r < 0L, g > 0L))
expect_equal(or3s(qmy == 1L, q < 1L, j > 1L),
bor3(qmy == 1L, q < 1L, j > 1L))
expect_equal(or3s(qmz == 9L, n < 9L, d > 9L),
bor3(qmz == 9L, n < 9L, d > 9L))
expect_equal(or3s(qna == 0L, , ),
bor3(qna == 0L, , ))
expect_equal(or3s(qnb == 1L, , ),
bor3(qnb == 1L, , ))
expect_equal(or3s(qnc == 9L, , ),
bor3(qnc == 9L, , ))
expect_equal(or3s(qnd == 0L, , d >= 0L),
bor3(qnd == 0L, , d >= 0L))
expect_equal(or3s(qne == 1L, , x >= 1L),
bor3(qne == 1L, , x >= 1L))
expect_equal(or3s(qnf == 9L, , o >= 9L),
bor3(qnf == 9L, , o >= 9L))
expect_equal(or3s(qng == 0L, z < 0L, ),
bor3(qng == 0L, z < 0L, ))
expect_equal(or3s(qnh == 1L, g < 1L, ),
bor3(qnh == 1L, g < 1L, ))
expect_equal(or3s(qni == 9L, g < 9L, ),
bor3(qni == 9L, g < 9L, ))
expect_equal(or3s(qnj == 0L, s < 0L, h >= 0L),
bor3(qnj == 0L, s < 0L, h >= 0L))
expect_equal(or3s(qnk == 1L, x < 1L, d >= 1L),
bor3(qnk == 1L, x < 1L, d >= 1L))
expect_equal(or3s(qnl == 9L, z < 9L, w >= 9L),
bor3(qnl == 9L, z < 9L, w >= 9L))
expect_equal(or3s(qnm == 0L, , ),
bor3(qnm == 0L, , ))
expect_equal(or3s(qnn == 1L, , ),
bor3(qnn == 1L, , ))
expect_equal(or3s(qno == 9L, , ),
bor3(qno == 9L, , ))
expect_equal(or3s(qnp == 0L, , logi_p),
bor3(qnp == 0L, , logi_p))
expect_equal(or3s(qnq == 1L, , logi_s),
bor3(qnq == 1L, , logi_s))
expect_equal(or3s(qnr == 9L, , logi_q),
bor3(qnr == 9L, , logi_q))
expect_equal(or3s(qns == 0L, y <= 0L, ),
bor3(qns == 0L, y <= 0L, ))
expect_equal(or3s(qnt == 1L, y <= 1L, ),
bor3(qnt == 1L, y <= 1L, ))
expect_equal(or3s(qnu == 9L, m <= 9L, ),
bor3(qnu == 9L, m <= 9L, ))
expect_equal(or3s(qnv == 0L, x <= 0L, logi_p),
bor3(qnv == 0L, x <= 0L, logi_p))
expect_equal(or3s(qnw == 1L, h <= 1L, logi_k),
bor3(qnw == 1L, h <= 1L, logi_k))
expect_equal(or3s(qnx == 9L, y <= 9L, logi_w),
bor3(qnx == 9L, y <= 9L, logi_w))
expect_equal(or3s(qny == 0L, , ),
bor3(qny == 0L, , ))
expect_equal(or3s(qnz == 1L, , ),
bor3(qnz == 1L, , ))
expect_equal(or3s(qoa == 9L, , ),
bor3(qoa == 9L, , ))
expect_equal(or3s(qob == 0L, , !logi_e),
bor3(qob == 0L, , !logi_e))
expect_equal(or3s(qoc == 1L, , !logi_z),
bor3(qoc == 1L, , !logi_z))
expect_equal(or3s(qod == 9L, , !logi_q),
bor3(qod == 9L, , !logi_q))
expect_equal(or3s(qoe == 0L, t <= 0L, ),
bor3(qoe == 0L, t <= 0L, ))
expect_equal(or3s(qof == 1L, d <= 1L, ),
bor3(qof == 1L, d <= 1L, ))
expect_equal(or3s(qog == 9L, t <= 9L, ),
bor3(qog == 9L, t <= 9L, ))
expect_equal(or3s(qoh == 0L, v <= 0L, !logi_s),
bor3(qoh == 0L, v <= 0L, !logi_s))
expect_equal(or3s(qoi == 1L, h <= 1L, !logi_m),
bor3(qoi == 1L, h <= 1L, !logi_m))
expect_equal(or3s(qoj == 9L, f <= 9L, !logi_v),
bor3(qoj == 9L, f <= 9L, !logi_v))
expect_equal(or3s(qok == 0L, , ),
bor3(qok == 0L, , ))
expect_equal(or3s(qol == 1L, , ),
bor3(qol == 1L, , ))
expect_equal(or3s(qom == 9L, , ),
bor3(qom == 9L, , ))
expect_equal(or3s(qon == 0L, , m != 0L),
bor3(qon == 0L, , m != 0L))
expect_equal(or3s(qoo == 1L, , l != 1L),
bor3(qoo == 1L, , l != 1L))
expect_equal(or3s(qop == 9L, , p != 9L),
bor3(qop == 9L, , p != 9L))
expect_equal(or3s(qoq == 0L, a <= 0L, ),
bor3(qoq == 0L, a <= 0L, ))
expect_equal(or3s(qor == 1L, z <= 1L, ),
bor3(qor == 1L, z <= 1L, ))
expect_equal(or3s(qos == 9L, e <= 9L, ),
bor3(qos == 9L, e <= 9L, ))
expect_equal(or3s(qot == 0L, n <= 0L, i != 0L),
bor3(qot == 0L, n <= 0L, i != 0L))
expect_equal(or3s(qou == 1L, p <= 1L, t != 1L),
bor3(qou == 1L, p <= 1L, t != 1L))
expect_equal(or3s(qov == 9L, q <= 9L, y != 9L),
bor3(qov == 9L, q <= 9L, y != 9L))
expect_equal(or3s(qow == 0L, , ),
bor3(qow == 0L, , ))
expect_equal(or3s(qox == 1L, , ),
bor3(qox == 1L, , ))
expect_equal(or3s(qoy == 9L, , ),
bor3(qoy == 9L, , ))
expect_equal(or3s(qoz == 0L, , s %between% c(-1L, 1L)),
bor3(qoz == 0L, , s %between% c(-1L, 1L)))
expect_equal(or3s(qpa == 1L, , p %between% c(-1L, 1L)),
bor3(qpa == 1L, , p %between% c(-1L, 1L)))
expect_equal(or3s(qpb == 9L, , f %between% c(-1L, 1L)),
bor3(qpb == 9L, , f %between% c(-1L, 1L)))
expect_equal(or3s(qpc == 0L, r <= 0L, ),
bor3(qpc == 0L, r <= 0L, ))
expect_equal(or3s(qpd == 1L, y <= 1L, ),
bor3(qpd == 1L, y <= 1L, ))
expect_equal(or3s(qpe == 9L, w <= 9L, ),
bor3(qpe == 9L, w <= 9L, ))
expect_equal(or3s(qpf == 0L, t <= 0L, r %between% c(-1L, 1L)),
bor3(qpf == 0L, t <= 0L, r %between% c(-1L, 1L)))
expect_equal(or3s(qpg == 1L, m <= 1L, x %between% c(-1L, 1L)),
bor3(qpg == 1L, m <= 1L, x %between% c(-1L, 1L)))
expect_equal(or3s(qph == 9L, a <= 9L, f %between% c(-1L, 1L)),
bor3(qph == 9L, a <= 9L, f %between% c(-1L, 1L)))
expect_equal(or3s(qpi == 0L, , ),
bor3(qpi == 0L, , ))
expect_equal(or3s(qpj == 1L, , ),
bor3(qpj == 1L, , ))
expect_equal(or3s(qpk == 9L, , ),
bor3(qpk == 9L, , ))
expect_equal(or3s(qpl == 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qpl == 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qpm == 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qpm == 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qpn == 9L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qpn == 9L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qpo == 0L, m <= 0L, ),
bor3(qpo == 0L, m <= 0L, ))
expect_equal(or3s(qpp == 1L, f <= 1L, ),
bor3(qpp == 1L, f <= 1L, ))
expect_equal(or3s(qpq == 9L, z <= 9L, ),
bor3(qpq == 9L, z <= 9L, ))
expect_equal(or3s(qpr == 0L, f <= 0L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qpr == 0L, f <= 0L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qps == 1L, i <= 1L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qps == 1L, i <= 1L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qpt == 9L, k <= 9L, g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qpt == 9L, k <= 9L, g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qpu == 0L, , ),
bor3(qpu == 0L, , ))
expect_equal(or3s(qpv == 1L, , ),
bor3(qpv == 1L, , ))
expect_equal(or3s(qpw == 9L, , ),
bor3(qpw == 9L, , ))
expect_equal(or3s(qpx == 0L, , a %in% 1:4),
bor3(qpx == 0L, , a %in% 1:4))
expect_equal(or3s(qpy == 1L, , q %in% 1:4),
bor3(qpy == 1L, , q %in% 1:4))
expect_equal(or3s(qpz == 9L, , q %in% 1:4),
bor3(qpz == 9L, , q %in% 1:4))
expect_equal(or3s(qqa == 0L, k <= 0L, ),
bor3(qqa == 0L, k <= 0L, ))
expect_equal(or3s(qqb == 1L, a <= 1L, ),
bor3(qqb == 1L, a <= 1L, ))
expect_equal(or3s(qqc == 9L, w <= 9L, ),
bor3(qqc == 9L, w <= 9L, ))
expect_equal(or3s(qqd == 0L, k <= 0L, v %in% 1:4),
bor3(qqd == 0L, k <= 0L, v %in% 1:4))
expect_equal(or3s(qqe == 1L, j <= 1L, z %in% 1:4),
bor3(qqe == 1L, j <= 1L, z %in% 1:4))
expect_equal(or3s(qqf == 9L, p <= 9L, n %in% 1:4),
bor3(qqf == 9L, p <= 9L, n %in% 1:4))
expect_equal(or3s(qqg == 0L, , ),
bor3(qqg == 0L, , ))
expect_equal(or3s(qqh == 1L, , ),
bor3(qqh == 1L, , ))
expect_equal(or3s(qqi == 9L, , ),
bor3(qqi == 9L, , ))
expect_equal(or3s(qqj == 0L, , w < 0L),
bor3(qqj == 0L, , w < 0L))
expect_equal(or3s(qqk == 1L, , x < 1L),
bor3(qqk == 1L, , x < 1L))
expect_equal(or3s(qql == 9L, , o < 9L),
bor3(qql == 9L, , o < 9L))
expect_equal(or3s(qqm == 0L, b <= 0L, ),
bor3(qqm == 0L, b <= 0L, ))
expect_equal(or3s(qqn == 1L, g <= 1L, ),
bor3(qqn == 1L, g <= 1L, ))
expect_equal(or3s(qqo == 9L, x <= 9L, ),
bor3(qqo == 9L, x <= 9L, ))
expect_equal(or3s(qqp == 0L, a <= 0L, i < 0L),
bor3(qqp == 0L, a <= 0L, i < 0L))
expect_equal(or3s(qqq == 1L, j <= 1L, d < 1L),
bor3(qqq == 1L, j <= 1L, d < 1L))
expect_equal(or3s(qqr == 9L, r <= 9L, x < 9L),
bor3(qqr == 9L, r <= 9L, x < 9L))
expect_equal(or3s(qqs == 0L, , ),
bor3(qqs == 0L, , ))
expect_equal(or3s(qqt == 1L, , ),
bor3(qqt == 1L, , ))
expect_equal(or3s(qqu == 9L, , ),
bor3(qqu == 9L, , ))
expect_equal(or3s(qqv == 0L, , a <= 0L),
bor3(qqv == 0L, , a <= 0L))
expect_equal(or3s(qqw == 1L, , k <= 1L),
bor3(qqw == 1L, , k <= 1L))
expect_equal(or3s(qqx == 9L, , h <= 9L),
bor3(qqx == 9L, , h <= 9L))
expect_equal(or3s(qqy == 0L, u <= 0L, ),
bor3(qqy == 0L, u <= 0L, ))
expect_equal(or3s(qqz == 1L, y <= 1L, ),
bor3(qqz == 1L, y <= 1L, ))
expect_equal(or3s(qra == 9L, r <= 9L, ),
bor3(qra == 9L, r <= 9L, ))
expect_equal(or3s(qrb == 0L, o <= 0L, d <= 0L),
bor3(qrb == 0L, o <= 0L, d <= 0L))
expect_equal(or3s(qrc == 1L, n <= 1L, s <= 1L),
bor3(qrc == 1L, n <= 1L, s <= 1L))
expect_equal(or3s(qrd == 9L, q <= 9L, v <= 9L),
bor3(qrd == 9L, q <= 9L, v <= 9L))
expect_equal(or3s(qre == 0L, , ),
bor3(qre == 0L, , ))
expect_equal(or3s(qrf == 1L, , ),
bor3(qrf == 1L, , ))
expect_equal(or3s(qrg == 9L, , ),
bor3(qrg == 9L, , ))
expect_equal(or3s(qrh == 0L, , m == 0L),
bor3(qrh == 0L, , m == 0L))
expect_equal(or3s(qri == 1L, , w == 1L),
bor3(qri == 1L, , w == 1L))
expect_equal(or3s(qrj == 9L, , j == 9L),
bor3(qrj == 9L, , j == 9L))
expect_equal(or3s(qrk == 0L, r <= 0L, ),
bor3(qrk == 0L, r <= 0L, ))
expect_equal(or3s(qrl == 1L, x <= 1L, ),
bor3(qrl == 1L, x <= 1L, ))
expect_equal(or3s(qrm == 9L, s <= 9L, ),
bor3(qrm == 9L, s <= 9L, ))
expect_equal(or3s(qrn == 0L, m <= 0L, g == 0L),
bor3(qrn == 0L, m <= 0L, g == 0L))
expect_equal(or3s(qro == 1L, l <= 1L, k == 1L),
bor3(qro == 1L, l <= 1L, k == 1L))
expect_equal(or3s(qrp == 9L, h <= 9L, u == 9L),
bor3(qrp == 9L, h <= 9L, u == 9L))
expect_equal(or3s(qrq == 0L, , ),
bor3(qrq == 0L, , ))
expect_equal(or3s(qrr == 1L, , ),
bor3(qrr == 1L, , ))
expect_equal(or3s(qrs == 9L, , ),
bor3(qrs == 9L, , ))
expect_equal(or3s(qrt == 0L, , h > 0L),
bor3(qrt == 0L, , h > 0L))
expect_equal(or3s(qru == 1L, , q > 1L),
bor3(qru == 1L, , q > 1L))
expect_equal(or3s(qrv == 9L, , t > 9L),
bor3(qrv == 9L, , t > 9L))
expect_equal(or3s(qrw == 0L, e <= 0L, ),
bor3(qrw == 0L, e <= 0L, ))
expect_equal(or3s(qrx == 1L, u <= 1L, ),
bor3(qrx == 1L, u <= 1L, ))
expect_equal(or3s(qry == 9L, l <= 9L, ),
bor3(qry == 9L, l <= 9L, ))
expect_equal(or3s(qrz == 0L, w <= 0L, s > 0L),
bor3(qrz == 0L, w <= 0L, s > 0L))
expect_equal(or3s(qsa == 1L, x <= 1L, i > 1L),
bor3(qsa == 1L, x <= 1L, i > 1L))
expect_equal(or3s(qsb == 9L, x <= 9L, e > 9L),
bor3(qsb == 9L, x <= 9L, e > 9L))
expect_equal(or3s(qsc == 0L, , ),
bor3(qsc == 0L, , ))
expect_equal(or3s(qsd == 1L, , ),
bor3(qsd == 1L, , ))
expect_equal(or3s(qse == 9L, , ),
bor3(qse == 9L, , ))
expect_equal(or3s(qsf == 0L, , z >= 0L),
bor3(qsf == 0L, , z >= 0L))
expect_equal(or3s(qsg == 1L, , i >= 1L),
bor3(qsg == 1L, , i >= 1L))
expect_equal(or3s(qsh == 9L, , b >= 9L),
bor3(qsh == 9L, , b >= 9L))
expect_equal(or3s(qsi == 0L, s <= 0L, ),
bor3(qsi == 0L, s <= 0L, ))
expect_equal(or3s(qsj == 1L, k <= 1L, ),
bor3(qsj == 1L, k <= 1L, ))
expect_equal(or3s(qsk == 9L, e <= 9L, ),
bor3(qsk == 9L, e <= 9L, ))
expect_equal(or3s(qsl == 0L, j <= 0L, q >= 0L),
bor3(qsl == 0L, j <= 0L, q >= 0L))
expect_equal(or3s(qsm == 1L, v <= 1L, o >= 1L),
bor3(qsm == 1L, v <= 1L, o >= 1L))
expect_equal(or3s(qsn == 9L, s <= 9L, u >= 9L),
bor3(qsn == 9L, s <= 9L, u >= 9L))
expect_equal(or3s(qso == 0L, , ),
bor3(qso == 0L, , ))
expect_equal(or3s(qsp == 1L, , ),
bor3(qsp == 1L, , ))
expect_equal(or3s(qsq == 9L, , ),
bor3(qsq == 9L, , ))
expect_equal(or3s(qsr == 0L, , logi_v),
bor3(qsr == 0L, , logi_v))
expect_equal(or3s(qss == 1L, , logi_v),
bor3(qss == 1L, , logi_v))
expect_equal(or3s(qst == 9L, , logi_r),
bor3(qst == 9L, , logi_r))
expect_equal(or3s(qsu == 0L, w == 0L, ),
bor3(qsu == 0L, w == 0L, ))
expect_equal(or3s(qsv == 1L, g == 1L, ),
bor3(qsv == 1L, g == 1L, ))
expect_equal(or3s(qsw == 9L, l == 9L, ),
bor3(qsw == 9L, l == 9L, ))
expect_equal(or3s(qsx == 0L, x == 0L, logi_p),
bor3(qsx == 0L, x == 0L, logi_p))
expect_equal(or3s(qsy == 1L, w == 1L, logi_d),
bor3(qsy == 1L, w == 1L, logi_d))
expect_equal(or3s(qsz == 9L, h == 9L, logi_t),
bor3(qsz == 9L, h == 9L, logi_t))
expect_equal(or3s(qta == 0L, , ),
bor3(qta == 0L, , ))
expect_equal(or3s(qtb == 1L, , ),
bor3(qtb == 1L, , ))
expect_equal(or3s(qtc == 9L, , ),
bor3(qtc == 9L, , ))
expect_equal(or3s(qtd == 0L, , !logi_x),
bor3(qtd == 0L, , !logi_x))
expect_equal(or3s(qte == 1L, , !logi_c),
bor3(qte == 1L, , !logi_c))
expect_equal(or3s(qtf == 9L, , !logi_q),
bor3(qtf == 9L, , !logi_q))
expect_equal(or3s(qtg == 0L, m == 0L, ),
bor3(qtg == 0L, m == 0L, ))
expect_equal(or3s(qth == 1L, k == 1L, ),
bor3(qth == 1L, k == 1L, ))
expect_equal(or3s(qti == 9L, v == 9L, ),
bor3(qti == 9L, v == 9L, ))
expect_equal(or3s(qtj == 0L, m == 0L, !logi_z),
bor3(qtj == 0L, m == 0L, !logi_z))
expect_equal(or3s(qtk == 1L, v == 1L, !logi_z),
bor3(qtk == 1L, v == 1L, !logi_z))
expect_equal(or3s(qtl == 9L, c == 9L, !logi_i),
bor3(qtl == 9L, c == 9L, !logi_i))
expect_equal(or3s(qtm == 0L, , ),
bor3(qtm == 0L, , ))
expect_equal(or3s(qtn == 1L, , ),
bor3(qtn == 1L, , ))
expect_equal(or3s(qto == 9L, , ),
bor3(qto == 9L, , ))
expect_equal(or3s(qtp == 0L, , t != 0L),
bor3(qtp == 0L, , t != 0L))
expect_equal(or3s(qtq == 1L, , g != 1L),
bor3(qtq == 1L, , g != 1L))
expect_equal(or3s(qtr == 9L, , n != 9L),
bor3(qtr == 9L, , n != 9L))
expect_equal(or3s(qts == 0L, k == 0L, ),
bor3(qts == 0L, k == 0L, ))
expect_equal(or3s(qtt == 1L, z == 1L, ),
bor3(qtt == 1L, z == 1L, ))
expect_equal(or3s(qtu == 9L, l == 9L, ),
bor3(qtu == 9L, l == 9L, ))
expect_equal(or3s(qtv == 0L, x == 0L, u != 0L),
bor3(qtv == 0L, x == 0L, u != 0L))
expect_equal(or3s(qtw == 1L, w == 1L, d != 1L),
bor3(qtw == 1L, w == 1L, d != 1L))
expect_equal(or3s(qtx == 9L, a == 9L, x != 9L),
bor3(qtx == 9L, a == 9L, x != 9L))
expect_equal(or3s(qty == 0L, , ),
bor3(qty == 0L, , ))
expect_equal(or3s(qtz == 1L, , ),
bor3(qtz == 1L, , ))
expect_equal(or3s(qua == 9L, , ),
bor3(qua == 9L, , ))
expect_equal(or3s(qub == 0L, , o %between% c(-1L, 1L)),
bor3(qub == 0L, , o %between% c(-1L, 1L)))
expect_equal(or3s(quc == 1L, , g %between% c(-1L, 1L)),
bor3(quc == 1L, , g %between% c(-1L, 1L)))
expect_equal(or3s(qud == 9L, , e %between% c(-1L, 1L)),
bor3(qud == 9L, , e %between% c(-1L, 1L)))
expect_equal(or3s(que == 0L, e == 0L, ),
bor3(que == 0L, e == 0L, ))
expect_equal(or3s(quf == 1L, n == 1L, ),
bor3(quf == 1L, n == 1L, ))
expect_equal(or3s(qug == 9L, j == 9L, ),
bor3(qug == 9L, j == 9L, ))
expect_equal(or3s(quh == 0L, c == 0L, c %between% c(-1L, 1L)),
bor3(quh == 0L, c == 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(qui == 1L, f == 1L, w %between% c(-1L, 1L)),
bor3(qui == 1L, f == 1L, w %between% c(-1L, 1L)))
expect_equal(or3s(quj == 9L, w == 9L, d %between% c(-1L, 1L)),
bor3(quj == 9L, w == 9L, d %between% c(-1L, 1L)))
expect_equal(or3s(quk == 0L, , ),
bor3(quk == 0L, , ))
expect_equal(or3s(qul == 1L, , ),
bor3(qul == 1L, , ))
expect_equal(or3s(qum == 9L, , ),
bor3(qum == 9L, , ))
expect_equal(or3s(qun == 0L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qun == 0L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(quo == 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(quo == 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(qup == 9L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qup == 9L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(quq == 0L, z == 0L, ),
bor3(quq == 0L, z == 0L, ))
expect_equal(or3s(qur == 1L, w == 1L, ),
bor3(qur == 1L, w == 1L, ))
expect_equal(or3s(qus == 9L, t == 9L, ),
bor3(qus == 9L, t == 9L, ))
expect_equal(or3s(qut == 0L, f == 0L, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(qut == 0L, f == 0L, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(quu == 1L, c == 1L, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(quu == 1L, c == 1L, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(quv == 9L, m == 9L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(quv == 9L, m == 9L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(quw == 0L, , ),
bor3(quw == 0L, , ))
expect_equal(or3s(qux == 1L, , ),
bor3(qux == 1L, , ))
expect_equal(or3s(quy == 9L, , ),
bor3(quy == 9L, , ))
expect_equal(or3s(quz == 0L, , n %in% 1:4),
bor3(quz == 0L, , n %in% 1:4))
expect_equal(or3s(qva == 1L, , i %in% 1:4),
bor3(qva == 1L, , i %in% 1:4))
expect_equal(or3s(qvb == 9L, , b %in% 1:4),
bor3(qvb == 9L, , b %in% 1:4))
expect_equal(or3s(qvc == 0L, t == 0L, ),
bor3(qvc == 0L, t == 0L, ))
expect_equal(or3s(qvd == 1L, b == 1L, ),
bor3(qvd == 1L, b == 1L, ))
expect_equal(or3s(qve == 9L, c == 9L, ),
bor3(qve == 9L, c == 9L, ))
expect_equal(or3s(qvf == 0L, i == 0L, l %in% 1:4),
bor3(qvf == 0L, i == 0L, l %in% 1:4))
expect_equal(or3s(qvg == 1L, k == 1L, z %in% 1:4),
bor3(qvg == 1L, k == 1L, z %in% 1:4))
expect_equal(or3s(qvh == 9L, k == 9L, o %in% 1:4),
bor3(qvh == 9L, k == 9L, o %in% 1:4))
expect_equal(or3s(qvi == 0L, , ),
bor3(qvi == 0L, , ))
expect_equal(or3s(qvj == 1L, , ),
bor3(qvj == 1L, , ))
expect_equal(or3s(qvk == 9L, , ),
bor3(qvk == 9L, , ))
expect_equal(or3s(qvl == 0L, , s < 0L),
bor3(qvl == 0L, , s < 0L))
expect_equal(or3s(qvm == 1L, , b < 1L),
bor3(qvm == 1L, , b < 1L))
expect_equal(or3s(qvn == 9L, , s < 9L),
bor3(qvn == 9L, , s < 9L))
expect_equal(or3s(qvo == 0L, k == 0L, ),
bor3(qvo == 0L, k == 0L, ))
expect_equal(or3s(qvp == 1L, e == 1L, ),
bor3(qvp == 1L, e == 1L, ))
expect_equal(or3s(qvq == 9L, f == 9L, ),
bor3(qvq == 9L, f == 9L, ))
expect_equal(or3s(qvr == 0L, y == 0L, v < 0L),
bor3(qvr == 0L, y == 0L, v < 0L))
expect_equal(or3s(qvs == 1L, h == 1L, u < 1L),
bor3(qvs == 1L, h == 1L, u < 1L))
expect_equal(or3s(qvt == 9L, g == 9L, e < 9L),
bor3(qvt == 9L, g == 9L, e < 9L))
expect_equal(or3s(qvu == 0L, , ),
bor3(qvu == 0L, , ))
expect_equal(or3s(qvv == 1L, , ),
bor3(qvv == 1L, , ))
expect_equal(or3s(qvw == 9L, , ),
bor3(qvw == 9L, , ))
expect_equal(or3s(qvx == 0L, , f <= 0L),
bor3(qvx == 0L, , f <= 0L))
expect_equal(or3s(qvy == 1L, , x <= 1L),
bor3(qvy == 1L, , x <= 1L))
expect_equal(or3s(qvz == 9L, , g <= 9L),
bor3(qvz == 9L, , g <= 9L))
expect_equal(or3s(qwa == 0L, b == 0L, ),
bor3(qwa == 0L, b == 0L, ))
expect_equal(or3s(qwb == 1L, o == 1L, ),
bor3(qwb == 1L, o == 1L, ))
expect_equal(or3s(qwc == 9L, z == 9L, ),
bor3(qwc == 9L, z == 9L, ))
expect_equal(or3s(qwd == 0L, v == 0L, o <= 0L),
bor3(qwd == 0L, v == 0L, o <= 0L))
expect_equal(or3s(qwe == 1L, t == 1L, y <= 1L),
bor3(qwe == 1L, t == 1L, y <= 1L))
expect_equal(or3s(qwf == 9L, b == 9L, b <= 9L),
bor3(qwf == 9L, b == 9L, b <= 9L))
expect_equal(or3s(qwg == 0L, , ),
bor3(qwg == 0L, , ))
expect_equal(or3s(qwh == 1L, , ),
bor3(qwh == 1L, , ))
expect_equal(or3s(qwi == 9L, , ),
bor3(qwi == 9L, , ))
expect_equal(or3s(qwj == 0L, , y == 0L),
bor3(qwj == 0L, , y == 0L))
expect_equal(or3s(qwk == 1L, , w == 1L),
bor3(qwk == 1L, , w == 1L))
expect_equal(or3s(qwl == 9L, , o == 9L),
bor3(qwl == 9L, , o == 9L))
expect_equal(or3s(qwm == 0L, f == 0L, ),
bor3(qwm == 0L, f == 0L, ))
expect_equal(or3s(qwn == 1L, i == 1L, ),
bor3(qwn == 1L, i == 1L, ))
expect_equal(or3s(qwo == 9L, y == 9L, ),
bor3(qwo == 9L, y == 9L, ))
expect_equal(or3s(qwp == 0L, e == 0L, x == 0L),
bor3(qwp == 0L, e == 0L, x == 0L))
expect_equal(or3s(qwq == 1L, b == 1L, q == 1L),
bor3(qwq == 1L, b == 1L, q == 1L))
expect_equal(or3s(qwr == 9L, s == 9L, d == 9L),
bor3(qwr == 9L, s == 9L, d == 9L))
expect_equal(or3s(qws == 0L, , ),
bor3(qws == 0L, , ))
expect_equal(or3s(qwt == 1L, , ),
bor3(qwt == 1L, , ))
expect_equal(or3s(qwu == 9L, , ),
bor3(qwu == 9L, , ))
expect_equal(or3s(qwv == 0L, , d > 0L),
bor3(qwv == 0L, , d > 0L))
expect_equal(or3s(qww == 1L, , k > 1L),
bor3(qww == 1L, , k > 1L))
expect_equal(or3s(qwx == 9L, , g > 9L),
bor3(qwx == 9L, , g > 9L))
expect_equal(or3s(qwy == 0L, p == 0L, ),
bor3(qwy == 0L, p == 0L, ))
expect_equal(or3s(qwz == 1L, q == 1L, ),
bor3(qwz == 1L, q == 1L, ))
expect_equal(or3s(qxa == 9L, q == 9L, ),
bor3(qxa == 9L, q == 9L, ))
expect_equal(or3s(qxb == 0L, c == 0L, f > 0L),
bor3(qxb == 0L, c == 0L, f > 0L))
expect_equal(or3s(qxc == 1L, z == 1L, e > 1L),
bor3(qxc == 1L, z == 1L, e > 1L))
expect_equal(or3s(qxd == 9L, o == 9L, z > 9L),
bor3(qxd == 9L, o == 9L, z > 9L))
expect_equal(or3s(qxe == 0L, , ),
bor3(qxe == 0L, , ))
expect_equal(or3s(qxf == 1L, , ),
bor3(qxf == 1L, , ))
expect_equal(or3s(qxg == 9L, , ),
bor3(qxg == 9L, , ))
expect_equal(or3s(qxh == 0L, , o >= 0L),
bor3(qxh == 0L, , o >= 0L))
expect_equal(or3s(qxi == 1L, , o >= 1L),
bor3(qxi == 1L, , o >= 1L))
expect_equal(or3s(qxj == 9L, , h >= 9L),
bor3(qxj == 9L, , h >= 9L))
expect_equal(or3s(qxk == 0L, x == 0L, ),
bor3(qxk == 0L, x == 0L, ))
expect_equal(or3s(qxl == 1L, k == 1L, ),
bor3(qxl == 1L, k == 1L, ))
expect_equal(or3s(qxm == 9L, t == 9L, ),
bor3(qxm == 9L, t == 9L, ))
expect_equal(or3s(qxn == 0L, g == 0L, l >= 0L),
bor3(qxn == 0L, g == 0L, l >= 0L))
expect_equal(or3s(qxo == 1L, h == 1L, c >= 1L),
bor3(qxo == 1L, h == 1L, c >= 1L))
expect_equal(or3s(qxp == 9L, j == 9L, i >= 9L),
bor3(qxp == 9L, j == 9L, i >= 9L))
expect_equal(or3s(qxq == 0L, , ),
bor3(qxq == 0L, , ))
expect_equal(or3s(qxr == 1L, , ),
bor3(qxr == 1L, , ))
expect_equal(or3s(qxs == 9L, , ),
bor3(qxs == 9L, , ))
expect_equal(or3s(qxt == 0L, , logi_u),
bor3(qxt == 0L, , logi_u))
expect_equal(or3s(qxu == 1L, , logi_m),
bor3(qxu == 1L, , logi_m))
expect_equal(or3s(qxv == 9L, , logi_c),
bor3(qxv == 9L, , logi_c))
expect_equal(or3s(qxw == 0L, b > 0L, ),
bor3(qxw == 0L, b > 0L, ))
expect_equal(or3s(qxx == 1L, l > 1L, ),
bor3(qxx == 1L, l > 1L, ))
expect_equal(or3s(qxy == 9L, o > 9L, ),
bor3(qxy == 9L, o > 9L, ))
expect_equal(or3s(qxz == 0L, v > 0L, logi_n),
bor3(qxz == 0L, v > 0L, logi_n))
expect_equal(or3s(qya == 1L, z > 1L, logi_j),
bor3(qya == 1L, z > 1L, logi_j))
expect_equal(or3s(qyb == 9L, c > 9L, logi_n),
bor3(qyb == 9L, c > 9L, logi_n))
expect_equal(or3s(qyc == 0L, , ),
bor3(qyc == 0L, , ))
expect_equal(or3s(qyd == 1L, , ),
bor3(qyd == 1L, , ))
expect_equal(or3s(qye == 9L, , ),
bor3(qye == 9L, , ))
expect_equal(or3s(qyf == 0L, , !logi_q),
bor3(qyf == 0L, , !logi_q))
expect_equal(or3s(qyg == 1L, , !logi_g),
bor3(qyg == 1L, , !logi_g))
expect_equal(or3s(qyh == 9L, , !logi_q),
bor3(qyh == 9L, , !logi_q))
expect_equal(or3s(qyi == 0L, g > 0L, ),
bor3(qyi == 0L, g > 0L, ))
expect_equal(or3s(qyj == 1L, k > 1L, ),
bor3(qyj == 1L, k > 1L, ))
expect_equal(or3s(qyk == 9L, q > 9L, ),
bor3(qyk == 9L, q > 9L, ))
expect_equal(or3s(qyl == 0L, t > 0L, !logi_p),
bor3(qyl == 0L, t > 0L, !logi_p))
expect_equal(or3s(qym == 1L, m > 1L, !logi_c),
bor3(qym == 1L, m > 1L, !logi_c))
expect_equal(or3s(qyn == 9L, x > 9L, !logi_f),
bor3(qyn == 9L, x > 9L, !logi_f))
expect_equal(or3s(qyo == 0L, , ),
bor3(qyo == 0L, , ))
expect_equal(or3s(qyp == 1L, , ),
bor3(qyp == 1L, , ))
expect_equal(or3s(qyq == 9L, , ),
bor3(qyq == 9L, , ))
expect_equal(or3s(qyr == 0L, , g != 0L),
bor3(qyr == 0L, , g != 0L))
expect_equal(or3s(qys == 1L, , r != 1L),
bor3(qys == 1L, , r != 1L))
expect_equal(or3s(qyt == 9L, , x != 9L),
bor3(qyt == 9L, , x != 9L))
expect_equal(or3s(qyu == 0L, j > 0L, ),
bor3(qyu == 0L, j > 0L, ))
expect_equal(or3s(qyv == 1L, d > 1L, ),
bor3(qyv == 1L, d > 1L, ))
expect_equal(or3s(qyw == 9L, k > 9L, ),
bor3(qyw == 9L, k > 9L, ))
expect_equal(or3s(qyx == 0L, x > 0L, h != 0L),
bor3(qyx == 0L, x > 0L, h != 0L))
expect_equal(or3s(qyy == 1L, d > 1L, m != 1L),
bor3(qyy == 1L, d > 1L, m != 1L))
expect_equal(or3s(qyz == 9L, z > 9L, o != 9L),
bor3(qyz == 9L, z > 9L, o != 9L))
expect_equal(or3s(ra == 0L, , ),
bor3(ra == 0L, , ))
expect_equal(or3s(rb == 1L, , ),
bor3(rb == 1L, , ))
expect_equal(or3s(rc == 9L, , ),
bor3(rc == 9L, , ))
expect_equal(or3s(rd == 0L, , o %between% c(-1L, 1L)),
bor3(rd == 0L, , o %between% c(-1L, 1L)))
expect_equal(or3s(re == 1L, , e %between% c(-1L, 1L)),
bor3(re == 1L, , e %between% c(-1L, 1L)))
expect_equal(or3s(rf == 9L, , w %between% c(-1L, 1L)),
bor3(rf == 9L, , w %between% c(-1L, 1L)))
expect_equal(or3s(rg == 0L, q > 0L, ),
bor3(rg == 0L, q > 0L, ))
expect_equal(or3s(rh == 1L, x > 1L, ),
bor3(rh == 1L, x > 1L, ))
expect_equal(or3s(ri == 9L, u > 9L, ),
bor3(ri == 9L, u > 9L, ))
expect_equal(or3s(rj == 0L, x > 0L, w %between% c(-1L, 1L)),
bor3(rj == 0L, x > 0L, w %between% c(-1L, 1L)))
expect_equal(or3s(rk == 1L, c > 1L, d %between% c(-1L, 1L)),
bor3(rk == 1L, c > 1L, d %between% c(-1L, 1L)))
expect_equal(or3s(rl == 9L, c > 9L, a %between% c(-1L, 1L)),
bor3(rl == 9L, c > 9L, a %between% c(-1L, 1L)))
expect_equal(or3s(rm == 0L, , ),
bor3(rm == 0L, , ))
expect_equal(or3s(rn == 1L, , ),
bor3(rn == 1L, , ))
expect_equal(or3s(ro == 9L, , ),
bor3(ro == 9L, , ))
expect_equal(or3s(rp == 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rp == 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rq == 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rq == 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rr == 9L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rr == 9L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rs == 0L, l > 0L, ),
bor3(rs == 0L, l > 0L, ))
expect_equal(or3s(rt == 1L, w > 1L, ),
bor3(rt == 1L, w > 1L, ))
expect_equal(or3s(ru == 9L, v > 9L, ),
bor3(ru == 9L, v > 9L, ))
expect_equal(or3s(rv == 0L, b > 0L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rv == 0L, b > 0L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rw == 1L, k > 1L, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rw == 1L, k > 1L, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rx == 9L, q > 9L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rx == 9L, q > 9L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ry == 0L, , ),
bor3(ry == 0L, , ))
expect_equal(or3s(rz == 1L, , ),
bor3(rz == 1L, , ))
expect_equal(or3s(raa == 9L, , ),
bor3(raa == 9L, , ))
expect_equal(or3s(rab == 0L, , b %in% 1:4),
bor3(rab == 0L, , b %in% 1:4))
expect_equal(or3s(rac == 1L, , k %in% 1:4),
bor3(rac == 1L, , k %in% 1:4))
expect_equal(or3s(rad == 9L, , x %in% 1:4),
bor3(rad == 9L, , x %in% 1:4))
expect_equal(or3s(rae == 0L, v > 0L, ),
bor3(rae == 0L, v > 0L, ))
expect_equal(or3s(raf == 1L, j > 1L, ),
bor3(raf == 1L, j > 1L, ))
expect_equal(or3s(rag == 9L, r > 9L, ),
bor3(rag == 9L, r > 9L, ))
expect_equal(or3s(rah == 0L, w > 0L, k %in% 1:4),
bor3(rah == 0L, w > 0L, k %in% 1:4))
expect_equal(or3s(rai == 1L, d > 1L, a %in% 1:4),
bor3(rai == 1L, d > 1L, a %in% 1:4))
expect_equal(or3s(raj == 9L, y > 9L, h %in% 1:4),
bor3(raj == 9L, y > 9L, h %in% 1:4))
expect_equal(or3s(rak == 0L, , ),
bor3(rak == 0L, , ))
expect_equal(or3s(ral == 1L, , ),
bor3(ral == 1L, , ))
expect_equal(or3s(ram == 9L, , ),
bor3(ram == 9L, , ))
expect_equal(or3s(ran == 0L, , g < 0L),
bor3(ran == 0L, , g < 0L))
expect_equal(or3s(rao == 1L, , k < 1L),
bor3(rao == 1L, , k < 1L))
expect_equal(or3s(rap == 9L, , o < 9L),
bor3(rap == 9L, , o < 9L))
expect_equal(or3s(raq == 0L, n > 0L, ),
bor3(raq == 0L, n > 0L, ))
expect_equal(or3s(rar == 1L, p > 1L, ),
bor3(rar == 1L, p > 1L, ))
expect_equal(or3s(ras == 9L, w > 9L, ),
bor3(ras == 9L, w > 9L, ))
expect_equal(or3s(rat == 0L, b > 0L, y < 0L),
bor3(rat == 0L, b > 0L, y < 0L))
expect_equal(or3s(rau == 1L, o > 1L, c < 1L),
bor3(rau == 1L, o > 1L, c < 1L))
expect_equal(or3s(rav == 9L, g > 9L, k < 9L),
bor3(rav == 9L, g > 9L, k < 9L))
expect_equal(or3s(raw == 0L, , ),
bor3(raw == 0L, , ))
expect_equal(or3s(rax == 1L, , ),
bor3(rax == 1L, , ))
expect_equal(or3s(ray == 9L, , ),
bor3(ray == 9L, , ))
expect_equal(or3s(raz == 0L, , r <= 0L),
bor3(raz == 0L, , r <= 0L))
expect_equal(or3s(rba == 1L, , i <= 1L),
bor3(rba == 1L, , i <= 1L))
expect_equal(or3s(rbb == 9L, , j <= 9L),
bor3(rbb == 9L, , j <= 9L))
expect_equal(or3s(rbc == 0L, g > 0L, ),
bor3(rbc == 0L, g > 0L, ))
expect_equal(or3s(rbd == 1L, j > 1L, ),
bor3(rbd == 1L, j > 1L, ))
expect_equal(or3s(rbe == 9L, p > 9L, ),
bor3(rbe == 9L, p > 9L, ))
expect_equal(or3s(rbf == 0L, k > 0L, h <= 0L),
bor3(rbf == 0L, k > 0L, h <= 0L))
expect_equal(or3s(rbg == 1L, z > 1L, t <= 1L),
bor3(rbg == 1L, z > 1L, t <= 1L))
expect_equal(or3s(rbh == 9L, f > 9L, l <= 9L),
bor3(rbh == 9L, f > 9L, l <= 9L))
expect_equal(or3s(rbi == 0L, , ),
bor3(rbi == 0L, , ))
expect_equal(or3s(rbj == 1L, , ),
bor3(rbj == 1L, , ))
expect_equal(or3s(rbk == 9L, , ),
bor3(rbk == 9L, , ))
expect_equal(or3s(rbl == 0L, , v == 0L),
bor3(rbl == 0L, , v == 0L))
expect_equal(or3s(rbm == 1L, , x == 1L),
bor3(rbm == 1L, , x == 1L))
expect_equal(or3s(rbn == 9L, , x == 9L),
bor3(rbn == 9L, , x == 9L))
expect_equal(or3s(rbo == 0L, j > 0L, ),
bor3(rbo == 0L, j > 0L, ))
expect_equal(or3s(rbp == 1L, n > 1L, ),
bor3(rbp == 1L, n > 1L, ))
expect_equal(or3s(rbq == 9L, y > 9L, ),
bor3(rbq == 9L, y > 9L, ))
expect_equal(or3s(rbr == 0L, h > 0L, k == 0L),
bor3(rbr == 0L, h > 0L, k == 0L))
expect_equal(or3s(rbs == 1L, u > 1L, g == 1L),
bor3(rbs == 1L, u > 1L, g == 1L))
expect_equal(or3s(rbt == 9L, w > 9L, i == 9L),
bor3(rbt == 9L, w > 9L, i == 9L))
expect_equal(or3s(rbu == 0L, , ),
bor3(rbu == 0L, , ))
expect_equal(or3s(rbv == 1L, , ),
bor3(rbv == 1L, , ))
expect_equal(or3s(rbw == 9L, , ),
bor3(rbw == 9L, , ))
expect_equal(or3s(rbx == 0L, , n > 0L),
bor3(rbx == 0L, , n > 0L))
expect_equal(or3s(rby == 1L, , y > 1L),
bor3(rby == 1L, , y > 1L))
expect_equal(or3s(rbz == 9L, , j > 9L),
bor3(rbz == 9L, , j > 9L))
expect_equal(or3s(rca == 0L, z > 0L, ),
bor3(rca == 0L, z > 0L, ))
expect_equal(or3s(rcb == 1L, u > 1L, ),
bor3(rcb == 1L, u > 1L, ))
expect_equal(or3s(rcc == 9L, t > 9L, ),
bor3(rcc == 9L, t > 9L, ))
expect_equal(or3s(rcd == 0L, g > 0L, s > 0L),
bor3(rcd == 0L, g > 0L, s > 0L))
expect_equal(or3s(rce == 1L, i > 1L, d > 1L),
bor3(rce == 1L, i > 1L, d > 1L))
expect_equal(or3s(rcf == 9L, s > 9L, g > 9L),
bor3(rcf == 9L, s > 9L, g > 9L))
expect_equal(or3s(rcg == 0L, , ),
bor3(rcg == 0L, , ))
expect_equal(or3s(rch == 1L, , ),
bor3(rch == 1L, , ))
expect_equal(or3s(rci == 9L, , ),
bor3(rci == 9L, , ))
expect_equal(or3s(rcj == 0L, , k >= 0L),
bor3(rcj == 0L, , k >= 0L))
expect_equal(or3s(rck == 1L, , u >= 1L),
bor3(rck == 1L, , u >= 1L))
expect_equal(or3s(rcl == 9L, , q >= 9L),
bor3(rcl == 9L, , q >= 9L))
expect_equal(or3s(rcm == 0L, q > 0L, ),
bor3(rcm == 0L, q > 0L, ))
expect_equal(or3s(rcn == 1L, e > 1L, ),
bor3(rcn == 1L, e > 1L, ))
expect_equal(or3s(rco == 9L, f > 9L, ),
bor3(rco == 9L, f > 9L, ))
expect_equal(or3s(rcp == 0L, t > 0L, f >= 0L),
bor3(rcp == 0L, t > 0L, f >= 0L))
expect_equal(or3s(rcq == 1L, k > 1L, d >= 1L),
bor3(rcq == 1L, k > 1L, d >= 1L))
expect_equal(or3s(rcr == 9L, t > 9L, j >= 9L),
bor3(rcr == 9L, t > 9L, j >= 9L))
expect_equal(or3s(rcs == 0L, , ),
bor3(rcs == 0L, , ))
expect_equal(or3s(rct == 1L, , ),
bor3(rct == 1L, , ))
expect_equal(or3s(rcu == 9L, , ),
bor3(rcu == 9L, , ))
expect_equal(or3s(rcv == 0L, , logi_d),
bor3(rcv == 0L, , logi_d))
expect_equal(or3s(rcw == 1L, , logi_h),
bor3(rcw == 1L, , logi_h))
expect_equal(or3s(rcx == 9L, , logi_b),
bor3(rcx == 9L, , logi_b))
expect_equal(or3s(rcy == 0L, i >= 0L, ),
bor3(rcy == 0L, i >= 0L, ))
expect_equal(or3s(rcz == 1L, b >= 1L, ),
bor3(rcz == 1L, b >= 1L, ))
expect_equal(or3s(rda == 9L, a >= 9L, ),
bor3(rda == 9L, a >= 9L, ))
expect_equal(or3s(rdb == 0L, x >= 0L, logi_c),
bor3(rdb == 0L, x >= 0L, logi_c))
expect_equal(or3s(rdc == 1L, p >= 1L, logi_r),
bor3(rdc == 1L, p >= 1L, logi_r))
expect_equal(or3s(rdd == 9L, q >= 9L, logi_m),
bor3(rdd == 9L, q >= 9L, logi_m))
expect_equal(or3s(rde == 0L, , ),
bor3(rde == 0L, , ))
expect_equal(or3s(rdf == 1L, , ),
bor3(rdf == 1L, , ))
expect_equal(or3s(rdg == 9L, , ),
bor3(rdg == 9L, , ))
expect_equal(or3s(rdh == 0L, , !logi_d),
bor3(rdh == 0L, , !logi_d))
expect_equal(or3s(rdi == 1L, , !logi_j),
bor3(rdi == 1L, , !logi_j))
expect_equal(or3s(rdj == 9L, , !logi_n),
bor3(rdj == 9L, , !logi_n))
expect_equal(or3s(rdk == 0L, k >= 0L, ),
bor3(rdk == 0L, k >= 0L, ))
expect_equal(or3s(rdl == 1L, d >= 1L, ),
bor3(rdl == 1L, d >= 1L, ))
expect_equal(or3s(rdm == 9L, d >= 9L, ),
bor3(rdm == 9L, d >= 9L, ))
expect_equal(or3s(rdn == 0L, p >= 0L, !logi_h),
bor3(rdn == 0L, p >= 0L, !logi_h))
expect_equal(or3s(rdo == 1L, h >= 1L, !logi_n),
bor3(rdo == 1L, h >= 1L, !logi_n))
expect_equal(or3s(rdp == 9L, a >= 9L, !logi_z),
bor3(rdp == 9L, a >= 9L, !logi_z))
expect_equal(or3s(rdq == 0L, , ),
bor3(rdq == 0L, , ))
expect_equal(or3s(rdr == 1L, , ),
bor3(rdr == 1L, , ))
expect_equal(or3s(rds == 9L, , ),
bor3(rds == 9L, , ))
expect_equal(or3s(rdt == 0L, , o != 0L),
bor3(rdt == 0L, , o != 0L))
expect_equal(or3s(rdu == 1L, , c != 1L),
bor3(rdu == 1L, , c != 1L))
expect_equal(or3s(rdv == 9L, , a != 9L),
bor3(rdv == 9L, , a != 9L))
expect_equal(or3s(rdw == 0L, a >= 0L, ),
bor3(rdw == 0L, a >= 0L, ))
expect_equal(or3s(rdx == 1L, r >= 1L, ),
bor3(rdx == 1L, r >= 1L, ))
expect_equal(or3s(rdy == 9L, c >= 9L, ),
bor3(rdy == 9L, c >= 9L, ))
expect_equal(or3s(rdz == 0L, r >= 0L, x != 0L),
bor3(rdz == 0L, r >= 0L, x != 0L))
expect_equal(or3s(rea == 1L, y >= 1L, f != 1L),
bor3(rea == 1L, y >= 1L, f != 1L))
expect_equal(or3s(reb == 9L, t >= 9L, d != 9L),
bor3(reb == 9L, t >= 9L, d != 9L))
expect_equal(or3s(rec == 0L, , ),
bor3(rec == 0L, , ))
expect_equal(or3s(red == 1L, , ),
bor3(red == 1L, , ))
expect_equal(or3s(ree == 9L, , ),
bor3(ree == 9L, , ))
expect_equal(or3s(ref == 0L, , i %between% c(-1L, 1L)),
bor3(ref == 0L, , i %between% c(-1L, 1L)))
expect_equal(or3s(reg == 1L, , x %between% c(-1L, 1L)),
bor3(reg == 1L, , x %between% c(-1L, 1L)))
expect_equal(or3s(reh == 9L, , a %between% c(-1L, 1L)),
bor3(reh == 9L, , a %between% c(-1L, 1L)))
expect_equal(or3s(rei == 0L, c >= 0L, ),
bor3(rei == 0L, c >= 0L, ))
expect_equal(or3s(rej == 1L, w >= 1L, ),
bor3(rej == 1L, w >= 1L, ))
expect_equal(or3s(rek == 9L, o >= 9L, ),
bor3(rek == 9L, o >= 9L, ))
expect_equal(or3s(rel == 0L, i >= 0L, f %between% c(-1L, 1L)),
bor3(rel == 0L, i >= 0L, f %between% c(-1L, 1L)))
expect_equal(or3s(rem == 1L, x >= 1L, i %between% c(-1L, 1L)),
bor3(rem == 1L, x >= 1L, i %between% c(-1L, 1L)))
expect_equal(or3s(ren == 9L, a >= 9L, t %between% c(-1L, 1L)),
bor3(ren == 9L, a >= 9L, t %between% c(-1L, 1L)))
expect_equal(or3s(reo == 0L, , ),
bor3(reo == 0L, , ))
expect_equal(or3s(rep == 1L, , ),
bor3(rep == 1L, , ))
expect_equal(or3s(req == 9L, , ),
bor3(req == 9L, , ))
expect_equal(or3s(rer == 0L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rer == 0L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(res == 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(res == 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ret == 9L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ret == 9L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(reu == 0L, q >= 0L, ),
bor3(reu == 0L, q >= 0L, ))
expect_equal(or3s(rev == 1L, h >= 1L, ),
bor3(rev == 1L, h >= 1L, ))
expect_equal(or3s(rew == 9L, w >= 9L, ),
bor3(rew == 9L, w >= 9L, ))
expect_equal(or3s(rex == 0L, l >= 0L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rex == 0L, l >= 0L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rey == 1L, a >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rey == 1L, a >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rez == 9L, a >= 9L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rez == 9L, a >= 9L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rfa == 0L, , ),
bor3(rfa == 0L, , ))
expect_equal(or3s(rfb == 1L, , ),
bor3(rfb == 1L, , ))
expect_equal(or3s(rfc == 9L, , ),
bor3(rfc == 9L, , ))
expect_equal(or3s(rfd == 0L, , v %in% 1:4),
bor3(rfd == 0L, , v %in% 1:4))
expect_equal(or3s(rfe == 1L, , h %in% 1:4),
bor3(rfe == 1L, , h %in% 1:4))
expect_equal(or3s(rff == 9L, , q %in% 1:4),
bor3(rff == 9L, , q %in% 1:4))
expect_equal(or3s(rfg == 0L, s >= 0L, ),
bor3(rfg == 0L, s >= 0L, ))
expect_equal(or3s(rfh == 1L, b >= 1L, ),
bor3(rfh == 1L, b >= 1L, ))
expect_equal(or3s(rfi == 9L, q >= 9L, ),
bor3(rfi == 9L, q >= 9L, ))
expect_equal(or3s(rfj == 0L, k >= 0L, k %in% 1:4),
bor3(rfj == 0L, k >= 0L, k %in% 1:4))
expect_equal(or3s(rfk == 1L, t >= 1L, u %in% 1:4),
bor3(rfk == 1L, t >= 1L, u %in% 1:4))
expect_equal(or3s(rfl == 9L, s >= 9L, z %in% 1:4),
bor3(rfl == 9L, s >= 9L, z %in% 1:4))
expect_equal(or3s(rfm == 0L, , ),
bor3(rfm == 0L, , ))
expect_equal(or3s(rfn == 1L, , ),
bor3(rfn == 1L, , ))
expect_equal(or3s(rfo == 9L, , ),
bor3(rfo == 9L, , ))
expect_equal(or3s(rfp == 0L, , h < 0L),
bor3(rfp == 0L, , h < 0L))
expect_equal(or3s(rfq == 1L, , f < 1L),
bor3(rfq == 1L, , f < 1L))
expect_equal(or3s(rfr == 9L, , v < 9L),
bor3(rfr == 9L, , v < 9L))
expect_equal(or3s(rfs == 0L, i >= 0L, ),
bor3(rfs == 0L, i >= 0L, ))
expect_equal(or3s(rft == 1L, a >= 1L, ),
bor3(rft == 1L, a >= 1L, ))
expect_equal(or3s(rfu == 9L, d >= 9L, ),
bor3(rfu == 9L, d >= 9L, ))
expect_equal(or3s(rfv == 0L, q >= 0L, u < 0L),
bor3(rfv == 0L, q >= 0L, u < 0L))
expect_equal(or3s(rfw == 1L, f >= 1L, c < 1L),
bor3(rfw == 1L, f >= 1L, c < 1L))
expect_equal(or3s(rfx == 9L, a >= 9L, l < 9L),
bor3(rfx == 9L, a >= 9L, l < 9L))
expect_equal(or3s(rfy == 0L, , ),
bor3(rfy == 0L, , ))
expect_equal(or3s(rfz == 1L, , ),
bor3(rfz == 1L, , ))
expect_equal(or3s(rga == 9L, , ),
bor3(rga == 9L, , ))
expect_equal(or3s(rgb == 0L, , t <= 0L),
bor3(rgb == 0L, , t <= 0L))
expect_equal(or3s(rgc == 1L, , c <= 1L),
bor3(rgc == 1L, , c <= 1L))
expect_equal(or3s(rgd == 9L, , l <= 9L),
bor3(rgd == 9L, , l <= 9L))
expect_equal(or3s(rge == 0L, k >= 0L, ),
bor3(rge == 0L, k >= 0L, ))
expect_equal(or3s(rgf == 1L, e >= 1L, ),
bor3(rgf == 1L, e >= 1L, ))
expect_equal(or3s(rgg == 9L, p >= 9L, ),
bor3(rgg == 9L, p >= 9L, ))
expect_equal(or3s(rgh == 0L, o >= 0L, a <= 0L),
bor3(rgh == 0L, o >= 0L, a <= 0L))
expect_equal(or3s(rgi == 1L, m >= 1L, p <= 1L),
bor3(rgi == 1L, m >= 1L, p <= 1L))
expect_equal(or3s(rgj == 9L, r >= 9L, l <= 9L),
bor3(rgj == 9L, r >= 9L, l <= 9L))
expect_equal(or3s(rgk == 0L, , ),
bor3(rgk == 0L, , ))
expect_equal(or3s(rgl == 1L, , ),
bor3(rgl == 1L, , ))
expect_equal(or3s(rgm == 9L, , ),
bor3(rgm == 9L, , ))
expect_equal(or3s(rgn == 0L, , i == 0L),
bor3(rgn == 0L, , i == 0L))
expect_equal(or3s(rgo == 1L, , d == 1L),
bor3(rgo == 1L, , d == 1L))
expect_equal(or3s(rgp == 9L, , i == 9L),
bor3(rgp == 9L, , i == 9L))
expect_equal(or3s(rgq == 0L, k >= 0L, ),
bor3(rgq == 0L, k >= 0L, ))
expect_equal(or3s(rgr == 1L, v >= 1L, ),
bor3(rgr == 1L, v >= 1L, ))
expect_equal(or3s(rgs == 9L, w >= 9L, ),
bor3(rgs == 9L, w >= 9L, ))
expect_equal(or3s(rgt == 0L, j >= 0L, a == 0L),
bor3(rgt == 0L, j >= 0L, a == 0L))
expect_equal(or3s(rgu == 1L, o >= 1L, x == 1L),
bor3(rgu == 1L, o >= 1L, x == 1L))
expect_equal(or3s(rgv == 9L, j >= 9L, o == 9L),
bor3(rgv == 9L, j >= 9L, o == 9L))
expect_equal(or3s(rgw == 0L, , ),
bor3(rgw == 0L, , ))
expect_equal(or3s(rgx == 1L, , ),
bor3(rgx == 1L, , ))
expect_equal(or3s(rgy == 9L, , ),
bor3(rgy == 9L, , ))
expect_equal(or3s(rgz == 0L, , u > 0L),
bor3(rgz == 0L, , u > 0L))
expect_equal(or3s(rha == 1L, , k > 1L),
bor3(rha == 1L, , k > 1L))
expect_equal(or3s(rhb == 9L, , u > 9L),
bor3(rhb == 9L, , u > 9L))
expect_equal(or3s(rhc == 0L, y >= 0L, ),
bor3(rhc == 0L, y >= 0L, ))
expect_equal(or3s(rhd == 1L, c >= 1L, ),
bor3(rhd == 1L, c >= 1L, ))
expect_equal(or3s(rhe == 9L, p >= 9L, ),
bor3(rhe == 9L, p >= 9L, ))
expect_equal(or3s(rhf == 0L, n >= 0L, z > 0L),
bor3(rhf == 0L, n >= 0L, z > 0L))
expect_equal(or3s(rhg == 1L, a >= 1L, o > 1L),
bor3(rhg == 1L, a >= 1L, o > 1L))
expect_equal(or3s(rhh == 9L, q >= 9L, f > 9L),
bor3(rhh == 9L, q >= 9L, f > 9L))
expect_equal(or3s(rhi == 0L, , ),
bor3(rhi == 0L, , ))
expect_equal(or3s(rhj == 1L, , ),
bor3(rhj == 1L, , ))
expect_equal(or3s(rhk == 9L, , ),
bor3(rhk == 9L, , ))
expect_equal(or3s(rhl == 0L, , v >= 0L),
bor3(rhl == 0L, , v >= 0L))
expect_equal(or3s(rhm == 1L, , k >= 1L),
bor3(rhm == 1L, , k >= 1L))
expect_equal(or3s(rhn == 9L, , b >= 9L),
bor3(rhn == 9L, , b >= 9L))
expect_equal(or3s(rho == 0L, e >= 0L, ),
bor3(rho == 0L, e >= 0L, ))
expect_equal(or3s(rhp == 1L, j >= 1L, ),
bor3(rhp == 1L, j >= 1L, ))
expect_equal(or3s(rhq == 9L, v >= 9L, ),
bor3(rhq == 9L, v >= 9L, ))
expect_equal(or3s(rhr == 0L, u >= 0L, j >= 0L),
bor3(rhr == 0L, u >= 0L, j >= 0L))
expect_equal(or3s(rhs == 1L, q >= 1L, z >= 1L),
bor3(rhs == 1L, q >= 1L, z >= 1L))
expect_equal(or3s(rht == 9L, n >= 9L, i >= 9L),
bor3(rht == 9L, n >= 9L, i >= 9L))
expect_equal(or3s(rhu > 0L, , ),
bor3(rhu > 0L, , ))
expect_equal(or3s(rhv > 1L, , ),
bor3(rhv > 1L, , ))
expect_equal(or3s(rhw > 9L, , ),
bor3(rhw > 9L, , ))
expect_equal(or3s(rhx > 0L, , logi_t),
bor3(rhx > 0L, , logi_t))
expect_equal(or3s(rhy > 1L, , logi_i),
bor3(rhy > 1L, , logi_i))
expect_equal(or3s(rhz > 9L, , logi_m),
bor3(rhz > 9L, , logi_m))
expect_equal(or3s(ria > 0L, logi_q, ),
bor3(ria > 0L, logi_q, ))
expect_equal(or3s(rib > 1L, logi_v, ),
bor3(rib > 1L, logi_v, ))
expect_equal(or3s(ric > 9L, logi_j, ),
bor3(ric > 9L, logi_j, ))
expect_equal(or3s(rid > 0L, logi_b, logi_e),
bor3(rid > 0L, logi_b, logi_e))
expect_equal(or3s(rie > 1L, logi_s, logi_v),
bor3(rie > 1L, logi_s, logi_v))
expect_equal(or3s(rif > 9L, logi_q, logi_s),
bor3(rif > 9L, logi_q, logi_s))
expect_equal(or3s(rig > 0L, , ),
bor3(rig > 0L, , ))
expect_equal(or3s(rih > 1L, , ),
bor3(rih > 1L, , ))
expect_equal(or3s(rii > 9L, , ),
bor3(rii > 9L, , ))
expect_equal(or3s(rij > 0L, , !logi_y),
bor3(rij > 0L, , !logi_y))
expect_equal(or3s(rik > 1L, , !logi_g),
bor3(rik > 1L, , !logi_g))
expect_equal(or3s(ril > 9L, , !logi_m),
bor3(ril > 9L, , !logi_m))
expect_equal(or3s(rim > 0L, logi_l, ),
bor3(rim > 0L, logi_l, ))
expect_equal(or3s(rin > 1L, logi_f, ),
bor3(rin > 1L, logi_f, ))
expect_equal(or3s(rio > 9L, logi_u, ),
bor3(rio > 9L, logi_u, ))
expect_equal(or3s(rip > 0L, logi_d, !logi_s),
bor3(rip > 0L, logi_d, !logi_s))
expect_equal(or3s(riq > 1L, logi_j, !logi_z),
bor3(riq > 1L, logi_j, !logi_z))
expect_equal(or3s(rir > 9L, logi_z, !logi_i),
bor3(rir > 9L, logi_z, !logi_i))
expect_equal(or3s(ris > 0L, , ),
bor3(ris > 0L, , ))
expect_equal(or3s(rit > 1L, , ),
bor3(rit > 1L, , ))
expect_equal(or3s(riu > 9L, , ),
bor3(riu > 9L, , ))
expect_equal(or3s(riv > 0L, , u != 0L),
bor3(riv > 0L, , u != 0L))
expect_equal(or3s(riw > 1L, , c != 1L),
bor3(riw > 1L, , c != 1L))
expect_equal(or3s(rix > 9L, , q != 9L),
bor3(rix > 9L, , q != 9L))
expect_equal(or3s(riy > 0L, logi_q, ),
bor3(riy > 0L, logi_q, ))
expect_equal(or3s(riz > 1L, logi_f, ),
bor3(riz > 1L, logi_f, ))
expect_equal(or3s(rja > 9L, logi_q, ),
bor3(rja > 9L, logi_q, ))
expect_equal(or3s(rjb > 0L, logi_c, v != 0L),
bor3(rjb > 0L, logi_c, v != 0L))
expect_equal(or3s(rjc > 1L, logi_l, u != 1L),
bor3(rjc > 1L, logi_l, u != 1L))
expect_equal(or3s(rjd > 9L, logi_z, t != 9L),
bor3(rjd > 9L, logi_z, t != 9L))
expect_equal(or3s(rje > 0L, , ),
bor3(rje > 0L, , ))
expect_equal(or3s(rjf > 1L, , ),
bor3(rjf > 1L, , ))
expect_equal(or3s(rjg > 9L, , ),
bor3(rjg > 9L, , ))
expect_equal(or3s(rjh > 0L, , q %between% c(-1L, 1L)),
bor3(rjh > 0L, , q %between% c(-1L, 1L)))
expect_equal(or3s(rji > 1L, , d %between% c(-1L, 1L)),
bor3(rji > 1L, , d %between% c(-1L, 1L)))
expect_equal(or3s(rjj > 9L, , p %between% c(-1L, 1L)),
bor3(rjj > 9L, , p %between% c(-1L, 1L)))
expect_equal(or3s(rjk > 0L, logi_f, ),
bor3(rjk > 0L, logi_f, ))
expect_equal(or3s(rjl > 1L, logi_u, ),
bor3(rjl > 1L, logi_u, ))
expect_equal(or3s(rjm > 9L, logi_c, ),
bor3(rjm > 9L, logi_c, ))
expect_equal(or3s(rjn > 0L, logi_u, b %between% c(-1L, 1L)),
bor3(rjn > 0L, logi_u, b %between% c(-1L, 1L)))
expect_equal(or3s(rjo > 1L, logi_t, x %between% c(-1L, 1L)),
bor3(rjo > 1L, logi_t, x %between% c(-1L, 1L)))
expect_equal(or3s(rjp > 9L, logi_h, t %between% c(-1L, 1L)),
bor3(rjp > 9L, logi_h, t %between% c(-1L, 1L)))
expect_equal(or3s(rjq > 0L, , ),
bor3(rjq > 0L, , ))
expect_equal(or3s(rjr > 1L, , ),
bor3(rjr > 1L, , ))
expect_equal(or3s(rjs > 9L, , ),
bor3(rjs > 9L, , ))
expect_equal(or3s(rjt > 0L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rjt > 0L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rju > 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rju > 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rjv > 9L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rjv > 9L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rjw > 0L, logi_i, ),
bor3(rjw > 0L, logi_i, ))
expect_equal(or3s(rjx > 1L, logi_z, ),
bor3(rjx > 1L, logi_z, ))
expect_equal(or3s(rjy > 9L, logi_a, ),
bor3(rjy > 9L, logi_a, ))
expect_equal(or3s(rjz > 0L, logi_w, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rjz > 0L, logi_w, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rka > 1L, logi_j, z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rka > 1L, logi_j, z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rkb > 9L, logi_o, n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rkb > 9L, logi_o, n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rkc > 0L, , ),
bor3(rkc > 0L, , ))
expect_equal(or3s(rkd > 1L, , ),
bor3(rkd > 1L, , ))
expect_equal(or3s(rke > 9L, , ),
bor3(rke > 9L, , ))
expect_equal(or3s(rkf > 0L, , p %in% 1:4),
bor3(rkf > 0L, , p %in% 1:4))
expect_equal(or3s(rkg > 1L, , h %in% 1:4),
bor3(rkg > 1L, , h %in% 1:4))
expect_equal(or3s(rkh > 9L, , f %in% 1:4),
bor3(rkh > 9L, , f %in% 1:4))
expect_equal(or3s(rki > 0L, logi_q, ),
bor3(rki > 0L, logi_q, ))
expect_equal(or3s(rkj > 1L, logi_m, ),
bor3(rkj > 1L, logi_m, ))
expect_equal(or3s(rkk > 9L, logi_o, ),
bor3(rkk > 9L, logi_o, ))
expect_equal(or3s(rkl > 0L, logi_y, o %in% 1:4),
bor3(rkl > 0L, logi_y, o %in% 1:4))
expect_equal(or3s(rkm > 1L, logi_w, o %in% 1:4),
bor3(rkm > 1L, logi_w, o %in% 1:4))
expect_equal(or3s(rkn > 9L, logi_p, r %in% 1:4),
bor3(rkn > 9L, logi_p, r %in% 1:4))
expect_equal(or3s(rko > 0L, , ),
bor3(rko > 0L, , ))
expect_equal(or3s(rkp > 1L, , ),
bor3(rkp > 1L, , ))
expect_equal(or3s(rkq > 9L, , ),
bor3(rkq > 9L, , ))
expect_equal(or3s(rkr > 0L, , q < 0L),
bor3(rkr > 0L, , q < 0L))
expect_equal(or3s(rks > 1L, , s < 1L),
bor3(rks > 1L, , s < 1L))
expect_equal(or3s(rkt > 9L, , n < 9L),
bor3(rkt > 9L, , n < 9L))
expect_equal(or3s(rku > 0L, logi_n, ),
bor3(rku > 0L, logi_n, ))
expect_equal(or3s(rkv > 1L, logi_f, ),
bor3(rkv > 1L, logi_f, ))
expect_equal(or3s(rkw > 9L, logi_i, ),
bor3(rkw > 9L, logi_i, ))
expect_equal(or3s(rkx > 0L, logi_j, x < 0L),
bor3(rkx > 0L, logi_j, x < 0L))
expect_equal(or3s(rky > 1L, logi_w, v < 1L),
bor3(rky > 1L, logi_w, v < 1L))
expect_equal(or3s(rkz > 9L, logi_q, e < 9L),
bor3(rkz > 9L, logi_q, e < 9L))
expect_equal(or3s(rla > 0L, , ),
bor3(rla > 0L, , ))
expect_equal(or3s(rlb > 1L, , ),
bor3(rlb > 1L, , ))
expect_equal(or3s(rlc > 9L, , ),
bor3(rlc > 9L, , ))
expect_equal(or3s(rld > 0L, , t <= 0L),
bor3(rld > 0L, , t <= 0L))
expect_equal(or3s(rle > 1L, , l <= 1L),
bor3(rle > 1L, , l <= 1L))
expect_equal(or3s(rlf > 9L, , r <= 9L),
bor3(rlf > 9L, , r <= 9L))
expect_equal(or3s(rlg > 0L, logi_c, ),
bor3(rlg > 0L, logi_c, ))
expect_equal(or3s(rlh > 1L, logi_m, ),
bor3(rlh > 1L, logi_m, ))
expect_equal(or3s(rli > 9L, logi_n, ),
bor3(rli > 9L, logi_n, ))
expect_equal(or3s(rlj > 0L, logi_k, c <= 0L),
bor3(rlj > 0L, logi_k, c <= 0L))
expect_equal(or3s(rlk > 1L, logi_n, m <= 1L),
bor3(rlk > 1L, logi_n, m <= 1L))
expect_equal(or3s(rll > 9L, logi_t, b <= 9L),
bor3(rll > 9L, logi_t, b <= 9L))
expect_equal(or3s(rlm > 0L, , ),
bor3(rlm > 0L, , ))
expect_equal(or3s(rln > 1L, , ),
bor3(rln > 1L, , ))
expect_equal(or3s(rlo > 9L, , ),
bor3(rlo > 9L, , ))
expect_equal(or3s(rlp > 0L, , z == 0L),
bor3(rlp > 0L, , z == 0L))
expect_equal(or3s(rlq > 1L, , u == 1L),
bor3(rlq > 1L, , u == 1L))
expect_equal(or3s(rlr > 9L, , h == 9L),
bor3(rlr > 9L, , h == 9L))
expect_equal(or3s(rls > 0L, logi_j, ),
bor3(rls > 0L, logi_j, ))
expect_equal(or3s(rlt > 1L, logi_o, ),
bor3(rlt > 1L, logi_o, ))
expect_equal(or3s(rlu > 9L, logi_l, ),
bor3(rlu > 9L, logi_l, ))
expect_equal(or3s(rlv > 0L, logi_p, y == 0L),
bor3(rlv > 0L, logi_p, y == 0L))
expect_equal(or3s(rlw > 1L, logi_f, y == 1L),
bor3(rlw > 1L, logi_f, y == 1L))
expect_equal(or3s(rlx > 9L, logi_k, b == 9L),
bor3(rlx > 9L, logi_k, b == 9L))
expect_equal(or3s(rly > 0L, , ),
bor3(rly > 0L, , ))
expect_equal(or3s(rlz > 1L, , ),
bor3(rlz > 1L, , ))
expect_equal(or3s(rma > 9L, , ),
bor3(rma > 9L, , ))
expect_equal(or3s(rmb > 0L, , w > 0L),
bor3(rmb > 0L, , w > 0L))
expect_equal(or3s(rmc > 1L, , l > 1L),
bor3(rmc > 1L, , l > 1L))
expect_equal(or3s(rmd > 9L, , e > 9L),
bor3(rmd > 9L, , e > 9L))
expect_equal(or3s(rme > 0L, logi_r, ),
bor3(rme > 0L, logi_r, ))
expect_equal(or3s(rmf > 1L, logi_n, ),
bor3(rmf > 1L, logi_n, ))
expect_equal(or3s(rmg > 9L, logi_o, ),
bor3(rmg > 9L, logi_o, ))
expect_equal(or3s(rmh > 0L, logi_o, m > 0L),
bor3(rmh > 0L, logi_o, m > 0L))
expect_equal(or3s(rmi > 1L, logi_g, l > 1L),
bor3(rmi > 1L, logi_g, l > 1L))
expect_equal(or3s(rmj > 9L, logi_w, g > 9L),
bor3(rmj > 9L, logi_w, g > 9L))
expect_equal(or3s(rmk > 0L, , ),
bor3(rmk > 0L, , ))
expect_equal(or3s(rml > 1L, , ),
bor3(rml > 1L, , ))
expect_equal(or3s(rmm > 9L, , ),
bor3(rmm > 9L, , ))
expect_equal(or3s(rmn > 0L, , e >= 0L),
bor3(rmn > 0L, , e >= 0L))
expect_equal(or3s(rmo > 1L, , z >= 1L),
bor3(rmo > 1L, , z >= 1L))
expect_equal(or3s(rmp > 9L, , v >= 9L),
bor3(rmp > 9L, , v >= 9L))
expect_equal(or3s(rmq > 0L, logi_c, ),
bor3(rmq > 0L, logi_c, ))
expect_equal(or3s(rmr > 1L, logi_v, ),
bor3(rmr > 1L, logi_v, ))
expect_equal(or3s(rms > 9L, logi_p, ),
bor3(rms > 9L, logi_p, ))
expect_equal(or3s(rmt > 0L, logi_c, k >= 0L),
bor3(rmt > 0L, logi_c, k >= 0L))
expect_equal(or3s(rmu > 1L, logi_n, i >= 1L),
bor3(rmu > 1L, logi_n, i >= 1L))
expect_equal(or3s(rmv > 9L, logi_g, c >= 9L),
bor3(rmv > 9L, logi_g, c >= 9L))
expect_equal(or3s(rmw > 0L, , ),
bor3(rmw > 0L, , ))
expect_equal(or3s(rmx > 1L, , ),
bor3(rmx > 1L, , ))
expect_equal(or3s(rmy > 9L, , ),
bor3(rmy > 9L, , ))
expect_equal(or3s(rmz > 0L, , logi_f),
bor3(rmz > 0L, , logi_f))
expect_equal(or3s(rna > 1L, , logi_d),
bor3(rna > 1L, , logi_d))
expect_equal(or3s(rnb > 9L, , logi_h),
bor3(rnb > 9L, , logi_h))
expect_equal(or3s(rnc > 0L, !logi_e, ),
bor3(rnc > 0L, !logi_e, ))
expect_equal(or3s(rnd > 1L, !logi_d, ),
bor3(rnd > 1L, !logi_d, ))
expect_equal(or3s(rne > 9L, !logi_u, ),
bor3(rne > 9L, !logi_u, ))
expect_equal(or3s(rnf > 0L, !logi_v, logi_x),
bor3(rnf > 0L, !logi_v, logi_x))
expect_equal(or3s(rng > 1L, !logi_b, logi_d),
bor3(rng > 1L, !logi_b, logi_d))
expect_equal(or3s(rnh > 9L, !logi_y, logi_d),
bor3(rnh > 9L, !logi_y, logi_d))
expect_equal(or3s(rni > 0L, , ),
bor3(rni > 0L, , ))
expect_equal(or3s(rnj > 1L, , ),
bor3(rnj > 1L, , ))
expect_equal(or3s(rnk > 9L, , ),
bor3(rnk > 9L, , ))
expect_equal(or3s(rnl > 0L, , !logi_p),
bor3(rnl > 0L, , !logi_p))
expect_equal(or3s(rnm > 1L, , !logi_t),
bor3(rnm > 1L, , !logi_t))
expect_equal(or3s(rnn > 9L, , !logi_x),
bor3(rnn > 9L, , !logi_x))
expect_equal(or3s(rno > 0L, !logi_e, ),
bor3(rno > 0L, !logi_e, ))
expect_equal(or3s(rnp > 1L, !logi_y, ),
bor3(rnp > 1L, !logi_y, ))
expect_equal(or3s(rnq > 9L, !logi_b, ),
bor3(rnq > 9L, !logi_b, ))
expect_equal(or3s(rnr > 0L, !logi_s, !logi_m),
bor3(rnr > 0L, !logi_s, !logi_m))
expect_equal(or3s(rns > 1L, !logi_h, !logi_b),
bor3(rns > 1L, !logi_h, !logi_b))
expect_equal(or3s(rnt > 9L, !logi_o, !logi_c),
bor3(rnt > 9L, !logi_o, !logi_c))
expect_equal(or3s(rnu > 0L, , ),
bor3(rnu > 0L, , ))
expect_equal(or3s(rnv > 1L, , ),
bor3(rnv > 1L, , ))
expect_equal(or3s(rnw > 9L, , ),
bor3(rnw > 9L, , ))
expect_equal(or3s(rnx > 0L, , x != 0L),
bor3(rnx > 0L, , x != 0L))
expect_equal(or3s(rny > 1L, , a != 1L),
bor3(rny > 1L, , a != 1L))
expect_equal(or3s(rnz > 9L, , j != 9L),
bor3(rnz > 9L, , j != 9L))
expect_equal(or3s(roa > 0L, !logi_l, ),
bor3(roa > 0L, !logi_l, ))
expect_equal(or3s(rob > 1L, !logi_o, ),
bor3(rob > 1L, !logi_o, ))
expect_equal(or3s(roc > 9L, !logi_n, ),
bor3(roc > 9L, !logi_n, ))
expect_equal(or3s(rod > 0L, !logi_s, e != 0L),
bor3(rod > 0L, !logi_s, e != 0L))
expect_equal(or3s(roe > 1L, !logi_t, s != 1L),
bor3(roe > 1L, !logi_t, s != 1L))
expect_equal(or3s(rof > 9L, !logi_j, d != 9L),
bor3(rof > 9L, !logi_j, d != 9L))
expect_equal(or3s(rog > 0L, , ),
bor3(rog > 0L, , ))
expect_equal(or3s(roh > 1L, , ),
bor3(roh > 1L, , ))
expect_equal(or3s(roi > 9L, , ),
bor3(roi > 9L, , ))
expect_equal(or3s(roj > 0L, , h %between% c(-1L, 1L)),
bor3(roj > 0L, , h %between% c(-1L, 1L)))
expect_equal(or3s(rok > 1L, , n %between% c(-1L, 1L)),
bor3(rok > 1L, , n %between% c(-1L, 1L)))
expect_equal(or3s(rol > 9L, , i %between% c(-1L, 1L)),
bor3(rol > 9L, , i %between% c(-1L, 1L)))
expect_equal(or3s(rom > 0L, !logi_t, ),
bor3(rom > 0L, !logi_t, ))
expect_equal(or3s(ron > 1L, !logi_o, ),
bor3(ron > 1L, !logi_o, ))
expect_equal(or3s(roo > 9L, !logi_y, ),
bor3(roo > 9L, !logi_y, ))
expect_equal(or3s(rop > 0L, !logi_a, u %between% c(-1L, 1L)),
bor3(rop > 0L, !logi_a, u %between% c(-1L, 1L)))
expect_equal(or3s(roq > 1L, !logi_n, o %between% c(-1L, 1L)),
bor3(roq > 1L, !logi_n, o %between% c(-1L, 1L)))
expect_equal(or3s(ror > 9L, !logi_b, s %between% c(-1L, 1L)),
bor3(ror > 9L, !logi_b, s %between% c(-1L, 1L)))
expect_equal(or3s(ros > 0L, , ),
bor3(ros > 0L, , ))
expect_equal(or3s(rot > 1L, , ),
bor3(rot > 1L, , ))
expect_equal(or3s(rou > 9L, , ),
bor3(rou > 9L, , ))
expect_equal(or3s(rov > 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rov > 0L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(row > 1L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(row > 1L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rox > 9L, , j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rox > 9L, , j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(roy > 0L, !logi_u, ),
bor3(roy > 0L, !logi_u, ))
expect_equal(or3s(roz > 1L, !logi_o, ),
bor3(roz > 1L, !logi_o, ))
expect_equal(or3s(rpa > 9L, !logi_f, ),
bor3(rpa > 9L, !logi_f, ))
expect_equal(or3s(rpb > 0L, !logi_x, u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rpb > 0L, !logi_x, u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rpc > 1L, !logi_l, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rpc > 1L, !logi_l, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rpd > 9L, !logi_q, l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rpd > 9L, !logi_q, l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rpe > 0L, , ),
bor3(rpe > 0L, , ))
expect_equal(or3s(rpf > 1L, , ),
bor3(rpf > 1L, , ))
expect_equal(or3s(rpg > 9L, , ),
bor3(rpg > 9L, , ))
expect_equal(or3s(rph > 0L, , h %in% 1:4),
bor3(rph > 0L, , h %in% 1:4))
expect_equal(or3s(rpi > 1L, , u %in% 1:4),
bor3(rpi > 1L, , u %in% 1:4))
expect_equal(or3s(rpj > 9L, , r %in% 1:4),
bor3(rpj > 9L, , r %in% 1:4))
expect_equal(or3s(rpk > 0L, !logi_x, ),
bor3(rpk > 0L, !logi_x, ))
expect_equal(or3s(rpl > 1L, !logi_z, ),
bor3(rpl > 1L, !logi_z, ))
expect_equal(or3s(rpm > 9L, !logi_x, ),
bor3(rpm > 9L, !logi_x, ))
expect_equal(or3s(rpn > 0L, !logi_x, c %in% 1:4),
bor3(rpn > 0L, !logi_x, c %in% 1:4))
expect_equal(or3s(rpo > 1L, !logi_j, l %in% 1:4),
bor3(rpo > 1L, !logi_j, l %in% 1:4))
expect_equal(or3s(rpp > 9L, !logi_c, f %in% 1:4),
bor3(rpp > 9L, !logi_c, f %in% 1:4))
expect_equal(or3s(rpq > 0L, , ),
bor3(rpq > 0L, , ))
expect_equal(or3s(rpr > 1L, , ),
bor3(rpr > 1L, , ))
expect_equal(or3s(rps > 9L, , ),
bor3(rps > 9L, , ))
expect_equal(or3s(rpt > 0L, , p < 0L),
bor3(rpt > 0L, , p < 0L))
expect_equal(or3s(rpu > 1L, , i < 1L),
bor3(rpu > 1L, , i < 1L))
expect_equal(or3s(rpv > 9L, , d < 9L),
bor3(rpv > 9L, , d < 9L))
expect_equal(or3s(rpw > 0L, !logi_u, ),
bor3(rpw > 0L, !logi_u, ))
expect_equal(or3s(rpx > 1L, !logi_w, ),
bor3(rpx > 1L, !logi_w, ))
expect_equal(or3s(rpy > 9L, !logi_q, ),
bor3(rpy > 9L, !logi_q, ))
expect_equal(or3s(rpz > 0L, !logi_h, w < 0L),
bor3(rpz > 0L, !logi_h, w < 0L))
expect_equal(or3s(rqa > 1L, !logi_w, p < 1L),
bor3(rqa > 1L, !logi_w, p < 1L))
expect_equal(or3s(rqb > 9L, !logi_x, n < 9L),
bor3(rqb > 9L, !logi_x, n < 9L))
expect_equal(or3s(rqc > 0L, , ),
bor3(rqc > 0L, , ))
expect_equal(or3s(rqd > 1L, , ),
bor3(rqd > 1L, , ))
expect_equal(or3s(rqe > 9L, , ),
bor3(rqe > 9L, , ))
expect_equal(or3s(rqf > 0L, , h <= 0L),
bor3(rqf > 0L, , h <= 0L))
expect_equal(or3s(rqg > 1L, , j <= 1L),
bor3(rqg > 1L, , j <= 1L))
expect_equal(or3s(rqh > 9L, , l <= 9L),
bor3(rqh > 9L, , l <= 9L))
expect_equal(or3s(rqi > 0L, !logi_b, ),
bor3(rqi > 0L, !logi_b, ))
expect_equal(or3s(rqj > 1L, !logi_i, ),
bor3(rqj > 1L, !logi_i, ))
expect_equal(or3s(rqk > 9L, !logi_t, ),
bor3(rqk > 9L, !logi_t, ))
expect_equal(or3s(rql > 0L, !logi_s, s <= 0L),
bor3(rql > 0L, !logi_s, s <= 0L))
expect_equal(or3s(rqm > 1L, !logi_y, f <= 1L),
bor3(rqm > 1L, !logi_y, f <= 1L))
expect_equal(or3s(rqn > 9L, !logi_b, y <= 9L),
bor3(rqn > 9L, !logi_b, y <= 9L))
expect_equal(or3s(rqo > 0L, , ),
bor3(rqo > 0L, , ))
expect_equal(or3s(rqp > 1L, , ),
bor3(rqp > 1L, , ))
expect_equal(or3s(rqq > 9L, , ),
bor3(rqq > 9L, , ))
expect_equal(or3s(rqr > 0L, , c == 0L),
bor3(rqr > 0L, , c == 0L))
expect_equal(or3s(rqs > 1L, , d == 1L),
bor3(rqs > 1L, , d == 1L))
expect_equal(or3s(rqt > 9L, , r == 9L),
bor3(rqt > 9L, , r == 9L))
expect_equal(or3s(rqu > 0L, !logi_b, ),
bor3(rqu > 0L, !logi_b, ))
expect_equal(or3s(rqv > 1L, !logi_c, ),
bor3(rqv > 1L, !logi_c, ))
expect_equal(or3s(rqw > 9L, !logi_v, ),
bor3(rqw > 9L, !logi_v, ))
expect_equal(or3s(rqx > 0L, !logi_k, r == 0L),
bor3(rqx > 0L, !logi_k, r == 0L))
expect_equal(or3s(rqy > 1L, !logi_e, t == 1L),
bor3(rqy > 1L, !logi_e, t == 1L))
expect_equal(or3s(rqz > 9L, !logi_v, j == 9L),
bor3(rqz > 9L, !logi_v, j == 9L))
expect_equal(or3s(rra > 0L, , ),
bor3(rra > 0L, , ))
expect_equal(or3s(rrb > 1L, , ),
bor3(rrb > 1L, , ))
expect_equal(or3s(rrc > 9L, , ),
bor3(rrc > 9L, , ))
expect_equal(or3s(rrd > 0L, , k > 0L),
bor3(rrd > 0L, , k > 0L))
expect_equal(or3s(rre > 1L, , x > 1L),
bor3(rre > 1L, , x > 1L))
expect_equal(or3s(rrf > 9L, , a > 9L),
bor3(rrf > 9L, , a > 9L))
expect_equal(or3s(rrg > 0L, !logi_r, ),
bor3(rrg > 0L, !logi_r, ))
expect_equal(or3s(rrh > 1L, !logi_k, ),
bor3(rrh > 1L, !logi_k, ))
expect_equal(or3s(rri > 9L, !logi_h, ),
bor3(rri > 9L, !logi_h, ))
expect_equal(or3s(rrj > 0L, !logi_p, e > 0L),
bor3(rrj > 0L, !logi_p, e > 0L))
expect_equal(or3s(rrk > 1L, !logi_i, b > 1L),
bor3(rrk > 1L, !logi_i, b > 1L))
expect_equal(or3s(rrl > 9L, !logi_n, y > 9L),
bor3(rrl > 9L, !logi_n, y > 9L))
expect_equal(or3s(rrm > 0L, , ),
bor3(rrm > 0L, , ))
expect_equal(or3s(rrn > 1L, , ),
bor3(rrn > 1L, , ))
expect_equal(or3s(rro > 9L, , ),
bor3(rro > 9L, , ))
expect_equal(or3s(rrp > 0L, , x >= 0L),
bor3(rrp > 0L, , x >= 0L))
expect_equal(or3s(rrq > 1L, , u >= 1L),
bor3(rrq > 1L, , u >= 1L))
expect_equal(or3s(rrr > 9L, , x >= 9L),
bor3(rrr > 9L, , x >= 9L))
expect_equal(or3s(rrs > 0L, !logi_r, ),
bor3(rrs > 0L, !logi_r, ))
expect_equal(or3s(rrt > 1L, !logi_y, ),
bor3(rrt > 1L, !logi_y, ))
expect_equal(or3s(rru > 9L, !logi_k, ),
bor3(rru > 9L, !logi_k, ))
expect_equal(or3s(rrv > 0L, !logi_x, b >= 0L),
bor3(rrv > 0L, !logi_x, b >= 0L))
expect_equal(or3s(rrw > 1L, !logi_e, h >= 1L),
bor3(rrw > 1L, !logi_e, h >= 1L))
expect_equal(or3s(rrx > 9L, !logi_y, d >= 9L),
bor3(rrx > 9L, !logi_y, d >= 9L))
expect_equal(or3s(rry > 0L, , ),
bor3(rry > 0L, , ))
expect_equal(or3s(rrz > 1L, , ),
bor3(rrz > 1L, , ))
expect_equal(or3s(rsa > 9L, , ),
bor3(rsa > 9L, , ))
expect_equal(or3s(rsb > 0L, , logi_y),
bor3(rsb > 0L, , logi_y))
expect_equal(or3s(rsc > 1L, , logi_a),
bor3(rsc > 1L, , logi_a))
expect_equal(or3s(rsd > 9L, , logi_o),
bor3(rsd > 9L, , logi_o))
expect_equal(or3s(rse > 0L, l != 0L, ),
bor3(rse > 0L, l != 0L, ))
expect_equal(or3s(rsf > 1L, a != 1L, ),
bor3(rsf > 1L, a != 1L, ))
expect_equal(or3s(rsg > 9L, q != 9L, ),
bor3(rsg > 9L, q != 9L, ))
expect_equal(or3s(rsh > 0L, k != 0L, logi_l),
bor3(rsh > 0L, k != 0L, logi_l))
expect_equal(or3s(rsi > 1L, u != 1L, logi_m),
bor3(rsi > 1L, u != 1L, logi_m))
expect_equal(or3s(rsj > 9L, c != 9L, logi_n),
bor3(rsj > 9L, c != 9L, logi_n))
expect_equal(or3s(rsk > 0L, , ),
bor3(rsk > 0L, , ))
expect_equal(or3s(rsl > 1L, , ),
bor3(rsl > 1L, , ))
expect_equal(or3s(rsm > 9L, , ),
bor3(rsm > 9L, , ))
expect_equal(or3s(rsn > 0L, , !logi_n),
bor3(rsn > 0L, , !logi_n))
expect_equal(or3s(rso > 1L, , !logi_c),
bor3(rso > 1L, , !logi_c))
expect_equal(or3s(rsp > 9L, , !logi_w),
bor3(rsp > 9L, , !logi_w))
expect_equal(or3s(rsq > 0L, q != 0L, ),
bor3(rsq > 0L, q != 0L, ))
expect_equal(or3s(rsr > 1L, i != 1L, ),
bor3(rsr > 1L, i != 1L, ))
expect_equal(or3s(rss > 9L, r != 9L, ),
bor3(rss > 9L, r != 9L, ))
expect_equal(or3s(rst > 0L, o != 0L, !logi_v),
bor3(rst > 0L, o != 0L, !logi_v))
expect_equal(or3s(rsu > 1L, c != 1L, !logi_t),
bor3(rsu > 1L, c != 1L, !logi_t))
expect_equal(or3s(rsv > 9L, u != 9L, !logi_k),
bor3(rsv > 9L, u != 9L, !logi_k))
expect_equal(or3s(rsw > 0L, , ),
bor3(rsw > 0L, , ))
expect_equal(or3s(rsx > 1L, , ),
bor3(rsx > 1L, , ))
expect_equal(or3s(rsy > 9L, , ),
bor3(rsy > 9L, , ))
expect_equal(or3s(rsz > 0L, , f != 0L),
bor3(rsz > 0L, , f != 0L))
expect_equal(or3s(rta > 1L, , q != 1L),
bor3(rta > 1L, , q != 1L))
expect_equal(or3s(rtb > 9L, , k != 9L),
bor3(rtb > 9L, , k != 9L))
expect_equal(or3s(rtc > 0L, u != 0L, ),
bor3(rtc > 0L, u != 0L, ))
expect_equal(or3s(rtd > 1L, e != 1L, ),
bor3(rtd > 1L, e != 1L, ))
expect_equal(or3s(rte > 9L, t != 9L, ),
bor3(rte > 9L, t != 9L, ))
expect_equal(or3s(rtf > 0L, i != 0L, g != 0L),
bor3(rtf > 0L, i != 0L, g != 0L))
expect_equal(or3s(rtg > 1L, h != 1L, d != 1L),
bor3(rtg > 1L, h != 1L, d != 1L))
expect_equal(or3s(rth > 9L, i != 9L, m != 9L),
bor3(rth > 9L, i != 9L, m != 9L))
expect_equal(or3s(rti > 0L, , ),
bor3(rti > 0L, , ))
expect_equal(or3s(rtj > 1L, , ),
bor3(rtj > 1L, , ))
expect_equal(or3s(rtk > 9L, , ),
bor3(rtk > 9L, , ))
expect_equal(or3s(rtl > 0L, , n %between% c(-1L, 1L)),
bor3(rtl > 0L, , n %between% c(-1L, 1L)))
expect_equal(or3s(rtm > 1L, , v %between% c(-1L, 1L)),
bor3(rtm > 1L, , v %between% c(-1L, 1L)))
expect_equal(or3s(rtn > 9L, , k %between% c(-1L, 1L)),
bor3(rtn > 9L, , k %between% c(-1L, 1L)))
expect_equal(or3s(rto > 0L, y != 0L, ),
bor3(rto > 0L, y != 0L, ))
expect_equal(or3s(rtp > 1L, o != 1L, ),
bor3(rtp > 1L, o != 1L, ))
expect_equal(or3s(rtq > 9L, n != 9L, ),
bor3(rtq > 9L, n != 9L, ))
expect_equal(or3s(rtr > 0L, s != 0L, c %between% c(-1L, 1L)),
bor3(rtr > 0L, s != 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(rts > 1L, d != 1L, e %between% c(-1L, 1L)),
bor3(rts > 1L, d != 1L, e %between% c(-1L, 1L)))
expect_equal(or3s(rtt > 9L, q != 9L, j %between% c(-1L, 1L)),
bor3(rtt > 9L, q != 9L, j %between% c(-1L, 1L)))
expect_equal(or3s(rtu > 0L, , ),
bor3(rtu > 0L, , ))
expect_equal(or3s(rtv > 1L, , ),
bor3(rtv > 1L, , ))
expect_equal(or3s(rtw > 9L, , ),
bor3(rtw > 9L, , ))
expect_equal(or3s(rtx > 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rtx > 0L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rty > 1L, , x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rty > 1L, , x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rtz > 9L, , j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rtz > 9L, , j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rua > 0L, i != 0L, ),
bor3(rua > 0L, i != 0L, ))
expect_equal(or3s(rub > 1L, u != 1L, ),
bor3(rub > 1L, u != 1L, ))
expect_equal(or3s(ruc > 9L, y != 9L, ),
bor3(ruc > 9L, y != 9L, ))
expect_equal(or3s(rud > 0L, o != 0L, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rud > 0L, o != 0L, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rue > 1L, g != 1L, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(rue > 1L, g != 1L, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ruf > 9L, b != 9L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ruf > 9L, b != 9L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(rug > 0L, , ),
bor3(rug > 0L, , ))
expect_equal(or3s(ruh > 1L, , ),
bor3(ruh > 1L, , ))
expect_equal(or3s(rui > 9L, , ),
bor3(rui > 9L, , ))
expect_equal(or3s(ruj > 0L, , n %in% 1:4),
bor3(ruj > 0L, , n %in% 1:4))
expect_equal(or3s(ruk > 1L, , s %in% 1:4),
bor3(ruk > 1L, , s %in% 1:4))
expect_equal(or3s(rul > 9L, , o %in% 1:4),
bor3(rul > 9L, , o %in% 1:4))
expect_equal(or3s(rum > 0L, q != 0L, ),
bor3(rum > 0L, q != 0L, ))
expect_equal(or3s(run > 1L, m != 1L, ),
bor3(run > 1L, m != 1L, ))
expect_equal(or3s(ruo > 9L, c != 9L, ),
bor3(ruo > 9L, c != 9L, ))
expect_equal(or3s(rup > 0L, h != 0L, h %in% 1:4),
bor3(rup > 0L, h != 0L, h %in% 1:4))
expect_equal(or3s(ruq > 1L, u != 1L, o %in% 1:4),
bor3(ruq > 1L, u != 1L, o %in% 1:4))
expect_equal(or3s(rur > 9L, z != 9L, n %in% 1:4),
bor3(rur > 9L, z != 9L, n %in% 1:4))
expect_equal(or3s(rus > 0L, , ),
bor3(rus > 0L, , ))
expect_equal(or3s(rut > 1L, , ),
bor3(rut > 1L, , ))
expect_equal(or3s(ruu > 9L, , ),
bor3(ruu > 9L, , ))
expect_equal(or3s(ruv > 0L, , v < 0L),
bor3(ruv > 0L, , v < 0L))
expect_equal(or3s(ruw > 1L, , s < 1L),
bor3(ruw > 1L, , s < 1L))
expect_equal(or3s(rux > 9L, , a < 9L),
bor3(rux > 9L, , a < 9L))
expect_equal(or3s(ruy > 0L, z != 0L, ),
bor3(ruy > 0L, z != 0L, ))
expect_equal(or3s(ruz > 1L, b != 1L, ),
bor3(ruz > 1L, b != 1L, ))
expect_equal(or3s(rva > 9L, n != 9L, ),
bor3(rva > 9L, n != 9L, ))
expect_equal(or3s(rvb > 0L, v != 0L, r < 0L),
bor3(rvb > 0L, v != 0L, r < 0L))
expect_equal(or3s(rvc > 1L, p != 1L, j < 1L),
bor3(rvc > 1L, p != 1L, j < 1L))
expect_equal(or3s(rvd > 9L, q != 9L, z < 9L),
bor3(rvd > 9L, q != 9L, z < 9L))
expect_equal(or3s(rve > 0L, , ),
bor3(rve > 0L, , ))
expect_equal(or3s(rvf > 1L, , ),
bor3(rvf > 1L, , ))
expect_equal(or3s(rvg > 9L, , ),
bor3(rvg > 9L, , ))
expect_equal(or3s(rvh > 0L, , p <= 0L),
bor3(rvh > 0L, , p <= 0L))
expect_equal(or3s(rvi > 1L, , u <= 1L),
bor3(rvi > 1L, , u <= 1L))
expect_equal(or3s(rvj > 9L, , z <= 9L),
bor3(rvj > 9L, , z <= 9L))
expect_equal(or3s(rvk > 0L, s != 0L, ),
bor3(rvk > 0L, s != 0L, ))
expect_equal(or3s(rvl > 1L, f != 1L, ),
bor3(rvl > 1L, f != 1L, ))
expect_equal(or3s(rvm > 9L, s != 9L, ),
bor3(rvm > 9L, s != 9L, ))
expect_equal(or3s(rvn > 0L, k != 0L, x <= 0L),
bor3(rvn > 0L, k != 0L, x <= 0L))
expect_equal(or3s(rvo > 1L, i != 1L, q <= 1L),
bor3(rvo > 1L, i != 1L, q <= 1L))
expect_equal(or3s(rvp > 9L, l != 9L, v <= 9L),
bor3(rvp > 9L, l != 9L, v <= 9L))
expect_equal(or3s(rvq > 0L, , ),
bor3(rvq > 0L, , ))
expect_equal(or3s(rvr > 1L, , ),
bor3(rvr > 1L, , ))
expect_equal(or3s(rvs > 9L, , ),
bor3(rvs > 9L, , ))
expect_equal(or3s(rvt > 0L, , g == 0L),
bor3(rvt > 0L, , g == 0L))
expect_equal(or3s(rvu > 1L, , s == 1L),
bor3(rvu > 1L, , s == 1L))
expect_equal(or3s(rvv > 9L, , a == 9L),
bor3(rvv > 9L, , a == 9L))
expect_equal(or3s(rvw > 0L, z != 0L, ),
bor3(rvw > 0L, z != 0L, ))
expect_equal(or3s(rvx > 1L, t != 1L, ),
bor3(rvx > 1L, t != 1L, ))
expect_equal(or3s(rvy > 9L, m != 9L, ),
bor3(rvy > 9L, m != 9L, ))
expect_equal(or3s(rvz > 0L, u != 0L, d == 0L),
bor3(rvz > 0L, u != 0L, d == 0L))
expect_equal(or3s(rwa > 1L, j != 1L, o == 1L),
bor3(rwa > 1L, j != 1L, o == 1L))
expect_equal(or3s(rwb > 9L, b != 9L, l == 9L),
bor3(rwb > 9L, b != 9L, l == 9L))
expect_equal(or3s(rwc > 0L, , ),
bor3(rwc > 0L, , ))
expect_equal(or3s(rwd > 1L, , ),
bor3(rwd > 1L, , ))
expect_equal(or3s(rwe > 9L, , ),
bor3(rwe > 9L, , ))
expect_equal(or3s(rwf > 0L, , d > 0L),
bor3(rwf > 0L, , d > 0L))
expect_equal(or3s(rwg > 1L, , g > 1L),
bor3(rwg > 1L, , g > 1L))
expect_equal(or3s(rwh > 9L, , i > 9L),
bor3(rwh > 9L, , i > 9L))
expect_equal(or3s(rwi > 0L, g != 0L, ),
bor3(rwi > 0L, g != 0L, ))
expect_equal(or3s(rwj > 1L, e != 1L, ),
bor3(rwj > 1L, e != 1L, ))
expect_equal(or3s(rwk > 9L, n != 9L, ),
bor3(rwk > 9L, n != 9L, ))
expect_equal(or3s(rwl > 0L, f != 0L, j > 0L),
bor3(rwl > 0L, f != 0L, j > 0L))
expect_equal(or3s(rwm > 1L, h != 1L, s > 1L),
bor3(rwm > 1L, h != 1L, s > 1L))
expect_equal(or3s(rwn > 9L, n != 9L, q > 9L),
bor3(rwn > 9L, n != 9L, q > 9L))
expect_equal(or3s(rwo > 0L, , ),
bor3(rwo > 0L, , ))
expect_equal(or3s(rwp > 1L, , ),
bor3(rwp > 1L, , ))
expect_equal(or3s(rwq > 9L, , ),
bor3(rwq > 9L, , ))
expect_equal(or3s(rwr > 0L, , n >= 0L),
bor3(rwr > 0L, , n >= 0L))
expect_equal(or3s(rws > 1L, , z >= 1L),
bor3(rws > 1L, , z >= 1L))
expect_equal(or3s(rwt > 9L, , u >= 9L),
bor3(rwt > 9L, , u >= 9L))
expect_equal(or3s(rwu > 0L, w != 0L, ),
bor3(rwu > 0L, w != 0L, ))
expect_equal(or3s(rwv > 1L, g != 1L, ),
bor3(rwv > 1L, g != 1L, ))
expect_equal(or3s(rww > 9L, k != 9L, ),
bor3(rww > 9L, k != 9L, ))
expect_equal(or3s(rwx > 0L, r != 0L, m >= 0L),
bor3(rwx > 0L, r != 0L, m >= 0L))
expect_equal(or3s(rwy > 1L, q != 1L, i >= 1L),
bor3(rwy > 1L, q != 1L, i >= 1L))
expect_equal(or3s(rwz > 9L, p != 9L, u >= 9L),
bor3(rwz > 9L, p != 9L, u >= 9L))
expect_equal(or3s(rxa > 0L, , ),
bor3(rxa > 0L, , ))
expect_equal(or3s(rxb > 1L, , ),
bor3(rxb > 1L, , ))
expect_equal(or3s(rxc > 9L, , ),
bor3(rxc > 9L, , ))
expect_equal(or3s(rxd > 0L, , logi_e),
bor3(rxd > 0L, , logi_e))
expect_equal(or3s(rxe > 1L, , logi_b),
bor3(rxe > 1L, , logi_b))
expect_equal(or3s(rxf > 9L, , logi_t),
bor3(rxf > 9L, , logi_t))
expect_equal(or3s(rxg > 0L, i %between% c(-1L, 1L), ),
bor3(rxg > 0L, i %between% c(-1L, 1L), ))
expect_equal(or3s(rxh > 1L, m %between% c(-1L, 1L), ),
bor3(rxh > 1L, m %between% c(-1L, 1L), ))
expect_equal(or3s(rxi > 9L, l %between% c(-1L, 1L), ),
bor3(rxi > 9L, l %between% c(-1L, 1L), ))
expect_equal(or3s(rxj > 0L, g %between% c(-1L, 1L), logi_j),
bor3(rxj > 0L, g %between% c(-1L, 1L), logi_j))
expect_equal(or3s(rxk > 1L, t %between% c(-1L, 1L), logi_a),
bor3(rxk > 1L, t %between% c(-1L, 1L), logi_a))
expect_equal(or3s(rxl > 9L, i %between% c(-1L, 1L), logi_w),
bor3(rxl > 9L, i %between% c(-1L, 1L), logi_w))
expect_equal(or3s(rxm > 0L, , ),
bor3(rxm > 0L, , ))
expect_equal(or3s(rxn > 1L, , ),
bor3(rxn > 1L, , ))
expect_equal(or3s(rxo > 9L, , ),
bor3(rxo > 9L, , ))
expect_equal(or3s(rxp > 0L, , !logi_l),
bor3(rxp > 0L, , !logi_l))
expect_equal(or3s(rxq > 1L, , !logi_t),
bor3(rxq > 1L, , !logi_t))
expect_equal(or3s(rxr > 9L, , !logi_w),
bor3(rxr > 9L, , !logi_w))
expect_equal(or3s(rxs > 0L, f %between% c(-1L, 1L), ),
bor3(rxs > 0L, f %between% c(-1L, 1L), ))
expect_equal(or3s(rxt > 1L, o %between% c(-1L, 1L), ),
bor3(rxt > 1L, o %between% c(-1L, 1L), ))
expect_equal(or3s(rxu > 9L, p %between% c(-1L, 1L), ),
bor3(rxu > 9L, p %between% c(-1L, 1L), ))
expect_equal(or3s(rxv > 0L, p %between% c(-1L, 1L), !logi_z),
bor3(rxv > 0L, p %between% c(-1L, 1L), !logi_z))
expect_equal(or3s(rxw > 1L, k %between% c(-1L, 1L), !logi_b),
bor3(rxw > 1L, k %between% c(-1L, 1L), !logi_b))
expect_equal(or3s(rxx > 9L, t %between% c(-1L, 1L), !logi_z),
bor3(rxx > 9L, t %between% c(-1L, 1L), !logi_z))
expect_equal(or3s(rxy > 0L, , ),
bor3(rxy > 0L, , ))
expect_equal(or3s(rxz > 1L, , ),
bor3(rxz > 1L, , ))
expect_equal(or3s(rya > 9L, , ),
bor3(rya > 9L, , ))
expect_equal(or3s(ryb > 0L, , b != 0L),
bor3(ryb > 0L, , b != 0L))
expect_equal(or3s(ryc > 1L, , k != 1L),
bor3(ryc > 1L, , k != 1L))
expect_equal(or3s(ryd > 9L, , m != 9L),
bor3(ryd > 9L, , m != 9L))
expect_equal(or3s(rye > 0L, b %between% c(-1L, 1L), ),
bor3(rye > 0L, b %between% c(-1L, 1L), ))
expect_equal(or3s(ryf > 1L, z %between% c(-1L, 1L), ),
bor3(ryf > 1L, z %between% c(-1L, 1L), ))
expect_equal(or3s(ryg > 9L, x %between% c(-1L, 1L), ),
bor3(ryg > 9L, x %between% c(-1L, 1L), ))
expect_equal(or3s(ryh > 0L, i %between% c(-1L, 1L), m != 0L),
bor3(ryh > 0L, i %between% c(-1L, 1L), m != 0L))
expect_equal(or3s(ryi > 1L, v %between% c(-1L, 1L), e != 1L),
bor3(ryi > 1L, v %between% c(-1L, 1L), e != 1L))
expect_equal(or3s(ryj > 9L, k %between% c(-1L, 1L), u != 9L),
bor3(ryj > 9L, k %between% c(-1L, 1L), u != 9L))
expect_equal(or3s(ryk > 0L, , ),
bor3(ryk > 0L, , ))
expect_equal(or3s(ryl > 1L, , ),
bor3(ryl > 1L, , ))
expect_equal(or3s(rym > 9L, , ),
bor3(rym > 9L, , ))
expect_equal(or3s(ryn > 0L, , a %between% c(-1L, 1L)),
bor3(ryn > 0L, , a %between% c(-1L, 1L)))
expect_equal(or3s(ryo > 1L, , w %between% c(-1L, 1L)),
bor3(ryo > 1L, , w %between% c(-1L, 1L)))
expect_equal(or3s(ryp > 9L, , g %between% c(-1L, 1L)),
bor3(ryp > 9L, , g %between% c(-1L, 1L)))
expect_equal(or3s(ryq > 0L, a %between% c(-1L, 1L), ),
bor3(ryq > 0L, a %between% c(-1L, 1L), ))
expect_equal(or3s(ryr > 1L, q %between% c(-1L, 1L), ),
bor3(ryr > 1L, q %between% c(-1L, 1L), ))
expect_equal(or3s(rys > 9L, m %between% c(-1L, 1L), ),
bor3(rys > 9L, m %between% c(-1L, 1L), ))
expect_equal(or3s(ryt > 0L, g %between% c(-1L, 1L), f %between% c(-1L, 1L)),
bor3(ryt > 0L, g %between% c(-1L, 1L), f %between% c(-1L, 1L)))
expect_equal(or3s(ryu > 1L, g %between% c(-1L, 1L), n %between% c(-1L, 1L)),
bor3(ryu > 1L, g %between% c(-1L, 1L), n %between% c(-1L, 1L)))
expect_equal(or3s(ryv > 9L, j %between% c(-1L, 1L), e %between% c(-1L, 1L)),
bor3(ryv > 9L, j %between% c(-1L, 1L), e %between% c(-1L, 1L)))
expect_equal(or3s(ryw > 0L, , ),
bor3(ryw > 0L, , ))
expect_equal(or3s(ryx > 1L, , ),
bor3(ryx > 1L, , ))
expect_equal(or3s(ryy > 9L, , ),
bor3(ryy > 9L, , ))
expect_equal(or3s(ryz > 0L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ryz > 0L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sa > 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sa > 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sb > 9L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sb > 9L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sc > 0L, l %between% c(-1L, 1L), ),
bor3(sc > 0L, l %between% c(-1L, 1L), ))
expect_equal(or3s(sd > 1L, v %between% c(-1L, 1L), ),
bor3(sd > 1L, v %between% c(-1L, 1L), ))
expect_equal(or3s(se > 9L, w %between% c(-1L, 1L), ),
bor3(se > 9L, w %between% c(-1L, 1L), ))
expect_equal(or3s(sf > 0L, l %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sf > 0L, l %between% c(-1L, 1L), w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sg > 1L, y %between% c(-1L, 1L), h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sg > 1L, y %between% c(-1L, 1L), h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sh > 9L, x %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sh > 9L, x %between% c(-1L, 1L), s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(si > 0L, , ),
bor3(si > 0L, , ))
expect_equal(or3s(sj > 1L, , ),
bor3(sj > 1L, , ))
expect_equal(or3s(sk > 9L, , ),
bor3(sk > 9L, , ))
expect_equal(or3s(sl > 0L, , f %in% 1:4),
bor3(sl > 0L, , f %in% 1:4))
expect_equal(or3s(sm > 1L, , p %in% 1:4),
bor3(sm > 1L, , p %in% 1:4))
expect_equal(or3s(sn > 9L, , a %in% 1:4),
bor3(sn > 9L, , a %in% 1:4))
expect_equal(or3s(so > 0L, h %between% c(-1L, 1L), ),
bor3(so > 0L, h %between% c(-1L, 1L), ))
expect_equal(or3s(sp > 1L, k %between% c(-1L, 1L), ),
bor3(sp > 1L, k %between% c(-1L, 1L), ))
expect_equal(or3s(sq > 9L, u %between% c(-1L, 1L), ),
bor3(sq > 9L, u %between% c(-1L, 1L), ))
expect_equal(or3s(sr > 0L, r %between% c(-1L, 1L), r %in% 1:4),
bor3(sr > 0L, r %between% c(-1L, 1L), r %in% 1:4))
expect_equal(or3s(ss > 1L, e %between% c(-1L, 1L), j %in% 1:4),
bor3(ss > 1L, e %between% c(-1L, 1L), j %in% 1:4))
expect_equal(or3s(st > 9L, i %between% c(-1L, 1L), v %in% 1:4),
bor3(st > 9L, i %between% c(-1L, 1L), v %in% 1:4))
expect_equal(or3s(su > 0L, , ),
bor3(su > 0L, , ))
expect_equal(or3s(sv > 1L, , ),
bor3(sv > 1L, , ))
expect_equal(or3s(sw > 9L, , ),
bor3(sw > 9L, , ))
expect_equal(or3s(sx > 0L, , h < 0L),
bor3(sx > 0L, , h < 0L))
expect_equal(or3s(sy > 1L, , k < 1L),
bor3(sy > 1L, , k < 1L))
expect_equal(or3s(sz > 9L, , n < 9L),
bor3(sz > 9L, , n < 9L))
expect_equal(or3s(saa > 0L, a %between% c(-1L, 1L), ),
bor3(saa > 0L, a %between% c(-1L, 1L), ))
expect_equal(or3s(sab > 1L, x %between% c(-1L, 1L), ),
bor3(sab > 1L, x %between% c(-1L, 1L), ))
expect_equal(or3s(sac > 9L, r %between% c(-1L, 1L), ),
bor3(sac > 9L, r %between% c(-1L, 1L), ))
expect_equal(or3s(sad > 0L, c %between% c(-1L, 1L), g < 0L),
bor3(sad > 0L, c %between% c(-1L, 1L), g < 0L))
expect_equal(or3s(sae > 1L, c %between% c(-1L, 1L), w < 1L),
bor3(sae > 1L, c %between% c(-1L, 1L), w < 1L))
expect_equal(or3s(saf > 9L, e %between% c(-1L, 1L), z < 9L),
bor3(saf > 9L, e %between% c(-1L, 1L), z < 9L))
expect_equal(or3s(sag > 0L, , ),
bor3(sag > 0L, , ))
expect_equal(or3s(sah > 1L, , ),
bor3(sah > 1L, , ))
expect_equal(or3s(sai > 9L, , ),
bor3(sai > 9L, , ))
expect_equal(or3s(saj > 0L, , m <= 0L),
bor3(saj > 0L, , m <= 0L))
expect_equal(or3s(sak > 1L, , k <= 1L),
bor3(sak > 1L, , k <= 1L))
expect_equal(or3s(sal > 9L, , s <= 9L),
bor3(sal > 9L, , s <= 9L))
expect_equal(or3s(sam > 0L, l %between% c(-1L, 1L), ),
bor3(sam > 0L, l %between% c(-1L, 1L), ))
expect_equal(or3s(san > 1L, k %between% c(-1L, 1L), ),
bor3(san > 1L, k %between% c(-1L, 1L), ))
expect_equal(or3s(sao > 9L, l %between% c(-1L, 1L), ),
bor3(sao > 9L, l %between% c(-1L, 1L), ))
expect_equal(or3s(sap > 0L, p %between% c(-1L, 1L), z <= 0L),
bor3(sap > 0L, p %between% c(-1L, 1L), z <= 0L))
expect_equal(or3s(saq > 1L, g %between% c(-1L, 1L), j <= 1L),
bor3(saq > 1L, g %between% c(-1L, 1L), j <= 1L))
expect_equal(or3s(sar > 9L, s %between% c(-1L, 1L), s <= 9L),
bor3(sar > 9L, s %between% c(-1L, 1L), s <= 9L))
expect_equal(or3s(sas > 0L, , ),
bor3(sas > 0L, , ))
expect_equal(or3s(sat > 1L, , ),
bor3(sat > 1L, , ))
expect_equal(or3s(sau > 9L, , ),
bor3(sau > 9L, , ))
expect_equal(or3s(sav > 0L, , r == 0L),
bor3(sav > 0L, , r == 0L))
expect_equal(or3s(saw > 1L, , s == 1L),
bor3(saw > 1L, , s == 1L))
expect_equal(or3s(sax > 9L, , j == 9L),
bor3(sax > 9L, , j == 9L))
expect_equal(or3s(say > 0L, w %between% c(-1L, 1L), ),
bor3(say > 0L, w %between% c(-1L, 1L), ))
expect_equal(or3s(saz > 1L, s %between% c(-1L, 1L), ),
bor3(saz > 1L, s %between% c(-1L, 1L), ))
expect_equal(or3s(sba > 9L, f %between% c(-1L, 1L), ),
bor3(sba > 9L, f %between% c(-1L, 1L), ))
expect_equal(or3s(sbb > 0L, u %between% c(-1L, 1L), w == 0L),
bor3(sbb > 0L, u %between% c(-1L, 1L), w == 0L))
expect_equal(or3s(sbc > 1L, a %between% c(-1L, 1L), g == 1L),
bor3(sbc > 1L, a %between% c(-1L, 1L), g == 1L))
expect_equal(or3s(sbd > 9L, o %between% c(-1L, 1L), e == 9L),
bor3(sbd > 9L, o %between% c(-1L, 1L), e == 9L))
expect_equal(or3s(sbe > 0L, , ),
bor3(sbe > 0L, , ))
expect_equal(or3s(sbf > 1L, , ),
bor3(sbf > 1L, , ))
expect_equal(or3s(sbg > 9L, , ),
bor3(sbg > 9L, , ))
expect_equal(or3s(sbh > 0L, , b > 0L),
bor3(sbh > 0L, , b > 0L))
expect_equal(or3s(sbi > 1L, , j > 1L),
bor3(sbi > 1L, , j > 1L))
expect_equal(or3s(sbj > 9L, , k > 9L),
bor3(sbj > 9L, , k > 9L))
expect_equal(or3s(sbk > 0L, f %between% c(-1L, 1L), ),
bor3(sbk > 0L, f %between% c(-1L, 1L), ))
expect_equal(or3s(sbl > 1L, f %between% c(-1L, 1L), ),
bor3(sbl > 1L, f %between% c(-1L, 1L), ))
expect_equal(or3s(sbm > 9L, h %between% c(-1L, 1L), ),
bor3(sbm > 9L, h %between% c(-1L, 1L), ))
expect_equal(or3s(sbn > 0L, k %between% c(-1L, 1L), t > 0L),
bor3(sbn > 0L, k %between% c(-1L, 1L), t > 0L))
expect_equal(or3s(sbo > 1L, y %between% c(-1L, 1L), g > 1L),
bor3(sbo > 1L, y %between% c(-1L, 1L), g > 1L))
expect_equal(or3s(sbp > 9L, i %between% c(-1L, 1L), n > 9L),
bor3(sbp > 9L, i %between% c(-1L, 1L), n > 9L))
expect_equal(or3s(sbq > 0L, , ),
bor3(sbq > 0L, , ))
expect_equal(or3s(sbr > 1L, , ),
bor3(sbr > 1L, , ))
expect_equal(or3s(sbs > 9L, , ),
bor3(sbs > 9L, , ))
expect_equal(or3s(sbt > 0L, , d >= 0L),
bor3(sbt > 0L, , d >= 0L))
expect_equal(or3s(sbu > 1L, , s >= 1L),
bor3(sbu > 1L, , s >= 1L))
expect_equal(or3s(sbv > 9L, , o >= 9L),
bor3(sbv > 9L, , o >= 9L))
expect_equal(or3s(sbw > 0L, v %between% c(-1L, 1L), ),
bor3(sbw > 0L, v %between% c(-1L, 1L), ))
expect_equal(or3s(sbx > 1L, b %between% c(-1L, 1L), ),
bor3(sbx > 1L, b %between% c(-1L, 1L), ))
expect_equal(or3s(sby > 9L, w %between% c(-1L, 1L), ),
bor3(sby > 9L, w %between% c(-1L, 1L), ))
expect_equal(or3s(sbz > 0L, j %between% c(-1L, 1L), u >= 0L),
bor3(sbz > 0L, j %between% c(-1L, 1L), u >= 0L))
expect_equal(or3s(sca > 1L, a %between% c(-1L, 1L), d >= 1L),
bor3(sca > 1L, a %between% c(-1L, 1L), d >= 1L))
expect_equal(or3s(scb > 9L, o %between% c(-1L, 1L), j >= 9L),
bor3(scb > 9L, o %between% c(-1L, 1L), j >= 9L))
expect_equal(or3s(scc > 0L, , ),
bor3(scc > 0L, , ))
expect_equal(or3s(scd > 1L, , ),
bor3(scd > 1L, , ))
expect_equal(or3s(sce > 9L, , ),
bor3(sce > 9L, , ))
expect_equal(or3s(scf > 0L, , logi_b),
bor3(scf > 0L, , logi_b))
expect_equal(or3s(scg > 1L, , logi_y),
bor3(scg > 1L, , logi_y))
expect_equal(or3s(sch > 9L, , logi_r),
bor3(sch > 9L, , logi_r))
expect_equal(or3s(sci > 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sci > 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(scj > 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(scj > 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sck > 9L, l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sck > 9L, l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(scl > 0L, k %in% c(4L, -3L, 2L, 7L, 8L), logi_k),
bor3(scl > 0L, k %in% c(4L, -3L, 2L, 7L, 8L), logi_k))
expect_equal(or3s(scm > 1L, c %in% c(4L, -3L, 2L, 7L, 8L), logi_t),
bor3(scm > 1L, c %in% c(4L, -3L, 2L, 7L, 8L), logi_t))
expect_equal(or3s(scn > 9L, b %in% c(4L, -3L, 2L, 7L, 8L), logi_o),
bor3(scn > 9L, b %in% c(4L, -3L, 2L, 7L, 8L), logi_o))
expect_equal(or3s(sco > 0L, , ),
bor3(sco > 0L, , ))
expect_equal(or3s(scp > 1L, , ),
bor3(scp > 1L, , ))
expect_equal(or3s(scq > 9L, , ),
bor3(scq > 9L, , ))
expect_equal(or3s(scr > 0L, , logi_v),
bor3(scr > 0L, , logi_v))
expect_equal(or3s(scs > 1L, , logi_n),
bor3(scs > 1L, , logi_n))
expect_equal(or3s(sct > 9L, , logi_l),
bor3(sct > 9L, , logi_l))
expect_equal(or3s(scu > 0L, y %in% 1:4, ),
bor3(scu > 0L, y %in% 1:4, ))
expect_equal(or3s(scv > 1L, h %in% 1:4, ),
bor3(scv > 1L, h %in% 1:4, ))
expect_equal(or3s(scw > 9L, w %in% 1:4, ),
bor3(scw > 9L, w %in% 1:4, ))
expect_equal(or3s(scx > 0L, c %in% 1:4, logi_v),
bor3(scx > 0L, c %in% 1:4, logi_v))
expect_equal(or3s(scy > 1L, v %in% 1:4, logi_k),
bor3(scy > 1L, v %in% 1:4, logi_k))
expect_equal(or3s(scz > 9L, h %in% 1:4, logi_f),
bor3(scz > 9L, h %in% 1:4, logi_f))
expect_equal(or3s(sda > 0L, , ),
bor3(sda > 0L, , ))
expect_equal(or3s(sdb > 1L, , ),
bor3(sdb > 1L, , ))
expect_equal(or3s(sdc > 9L, , ),
bor3(sdc > 9L, , ))
expect_equal(or3s(sdd > 0L, , !logi_y),
bor3(sdd > 0L, , !logi_y))
expect_equal(or3s(sde > 1L, , !logi_o),
bor3(sde > 1L, , !logi_o))
expect_equal(or3s(sdf > 9L, , !logi_t),
bor3(sdf > 9L, , !logi_t))
expect_equal(or3s(sdg > 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sdg > 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sdh > 1L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sdh > 1L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sdi > 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sdi > 9L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sdj > 0L, j %in% c(4L, -3L, 2L, 7L, 8L), !logi_z),
bor3(sdj > 0L, j %in% c(4L, -3L, 2L, 7L, 8L), !logi_z))
expect_equal(or3s(sdk > 1L, i %in% c(4L, -3L, 2L, 7L, 8L), !logi_t),
bor3(sdk > 1L, i %in% c(4L, -3L, 2L, 7L, 8L), !logi_t))
expect_equal(or3s(sdl > 9L, h %in% c(4L, -3L, 2L, 7L, 8L), !logi_c),
bor3(sdl > 9L, h %in% c(4L, -3L, 2L, 7L, 8L), !logi_c))
expect_equal(or3s(sdm > 0L, , ),
bor3(sdm > 0L, , ))
expect_equal(or3s(sdn > 1L, , ),
bor3(sdn > 1L, , ))
expect_equal(or3s(sdo > 9L, , ),
bor3(sdo > 9L, , ))
expect_equal(or3s(sdp > 0L, , !logi_v),
bor3(sdp > 0L, , !logi_v))
expect_equal(or3s(sdq > 1L, , !logi_b),
bor3(sdq > 1L, , !logi_b))
expect_equal(or3s(sdr > 9L, , !logi_t),
bor3(sdr > 9L, , !logi_t))
expect_equal(or3s(sds > 0L, v %in% 1:4, ),
bor3(sds > 0L, v %in% 1:4, ))
expect_equal(or3s(sdt > 1L, c %in% 1:4, ),
bor3(sdt > 1L, c %in% 1:4, ))
expect_equal(or3s(sdu > 9L, v %in% 1:4, ),
bor3(sdu > 9L, v %in% 1:4, ))
expect_equal(or3s(sdv > 0L, w %in% 1:4, !logi_l),
bor3(sdv > 0L, w %in% 1:4, !logi_l))
expect_equal(or3s(sdw > 1L, b %in% 1:4, !logi_t),
bor3(sdw > 1L, b %in% 1:4, !logi_t))
expect_equal(or3s(sdx > 9L, x %in% 1:4, !logi_x),
bor3(sdx > 9L, x %in% 1:4, !logi_x))
expect_equal(or3s(sdy > 0L, , ),
bor3(sdy > 0L, , ))
expect_equal(or3s(sdz > 1L, , ),
bor3(sdz > 1L, , ))
expect_equal(or3s(sea > 9L, , ),
bor3(sea > 9L, , ))
expect_equal(or3s(seb > 0L, , n != 0L),
bor3(seb > 0L, , n != 0L))
expect_equal(or3s(sec > 1L, , a != 1L),
bor3(sec > 1L, , a != 1L))
expect_equal(or3s(sed > 9L, , q != 9L),
bor3(sed > 9L, , q != 9L))
expect_equal(or3s(see > 0L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(see > 0L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sef > 1L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sef > 1L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(seg > 9L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(seg > 9L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(seh > 0L, m %in% c(4L, -3L, 2L, 7L, 8L), k != 0L),
bor3(seh > 0L, m %in% c(4L, -3L, 2L, 7L, 8L), k != 0L))
expect_equal(or3s(sei > 1L, v %in% c(4L, -3L, 2L, 7L, 8L), f != 1L),
bor3(sei > 1L, v %in% c(4L, -3L, 2L, 7L, 8L), f != 1L))
expect_equal(or3s(sej > 9L, x %in% c(4L, -3L, 2L, 7L, 8L), q != 9L),
bor3(sej > 9L, x %in% c(4L, -3L, 2L, 7L, 8L), q != 9L))
expect_equal(or3s(sek > 0L, , ),
bor3(sek > 0L, , ))
expect_equal(or3s(sel > 1L, , ),
bor3(sel > 1L, , ))
expect_equal(or3s(sem > 9L, , ),
bor3(sem > 9L, , ))
expect_equal(or3s(sen > 0L, , n != 0L),
bor3(sen > 0L, , n != 0L))
expect_equal(or3s(seo > 1L, , k != 1L),
bor3(seo > 1L, , k != 1L))
expect_equal(or3s(sep > 9L, , j != 9L),
bor3(sep > 9L, , j != 9L))
expect_equal(or3s(seq > 0L, z %in% 1:4, ),
bor3(seq > 0L, z %in% 1:4, ))
expect_equal(or3s(ser > 1L, g %in% 1:4, ),
bor3(ser > 1L, g %in% 1:4, ))
expect_equal(or3s(ses > 9L, x %in% 1:4, ),
bor3(ses > 9L, x %in% 1:4, ))
expect_equal(or3s(set > 0L, g %in% 1:4, w != 0L),
bor3(set > 0L, g %in% 1:4, w != 0L))
expect_equal(or3s(seu > 1L, a %in% 1:4, p != 1L),
bor3(seu > 1L, a %in% 1:4, p != 1L))
expect_equal(or3s(sev > 9L, g %in% 1:4, s != 9L),
bor3(sev > 9L, g %in% 1:4, s != 9L))
expect_equal(or3s(sew > 0L, , ),
bor3(sew > 0L, , ))
expect_equal(or3s(sex > 1L, , ),
bor3(sex > 1L, , ))
expect_equal(or3s(sey > 9L, , ),
bor3(sey > 9L, , ))
expect_equal(or3s(sez > 0L, , i %between% c(-1L, 1L)),
bor3(sez > 0L, , i %between% c(-1L, 1L)))
expect_equal(or3s(sfa > 1L, , d %between% c(-1L, 1L)),
bor3(sfa > 1L, , d %between% c(-1L, 1L)))
expect_equal(or3s(sfb > 9L, , w %between% c(-1L, 1L)),
bor3(sfb > 9L, , w %between% c(-1L, 1L)))
expect_equal(or3s(sfc > 0L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sfc > 0L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sfd > 1L, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sfd > 1L, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sfe > 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sfe > 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sff > 0L, d %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)),
bor3(sff > 0L, d %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)))
expect_equal(or3s(sfg > 1L, f %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L)),
bor3(sfg > 1L, f %in% c(4L, -3L, 2L, 7L, 8L), u %between% c(-1L, 1L)))
expect_equal(or3s(sfh > 9L, q %in% c(4L, -3L, 2L, 7L, 8L), f %between% c(-1L, 1L)),
bor3(sfh > 9L, q %in% c(4L, -3L, 2L, 7L, 8L), f %between% c(-1L, 1L)))
expect_equal(or3s(sfi > 0L, , ),
bor3(sfi > 0L, , ))
expect_equal(or3s(sfj > 1L, , ),
bor3(sfj > 1L, , ))
expect_equal(or3s(sfk > 9L, , ),
bor3(sfk > 9L, , ))
expect_equal(or3s(sfl > 0L, , k %between% c(-1L, 1L)),
bor3(sfl > 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(sfm > 1L, , y %between% c(-1L, 1L)),
bor3(sfm > 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(sfn > 9L, , n %between% c(-1L, 1L)),
bor3(sfn > 9L, , n %between% c(-1L, 1L)))
expect_equal(or3s(sfo > 0L, s %in% 1:4, ),
bor3(sfo > 0L, s %in% 1:4, ))
expect_equal(or3s(sfp > 1L, s %in% 1:4, ),
bor3(sfp > 1L, s %in% 1:4, ))
expect_equal(or3s(sfq > 9L, x %in% 1:4, ),
bor3(sfq > 9L, x %in% 1:4, ))
expect_equal(or3s(sfr > 0L, r %in% 1:4, t %between% c(-1L, 1L)),
bor3(sfr > 0L, r %in% 1:4, t %between% c(-1L, 1L)))
expect_equal(or3s(sfs > 1L, s %in% 1:4, g %between% c(-1L, 1L)),
bor3(sfs > 1L, s %in% 1:4, g %between% c(-1L, 1L)))
expect_equal(or3s(sft > 9L, o %in% 1:4, c %between% c(-1L, 1L)),
bor3(sft > 9L, o %in% 1:4, c %between% c(-1L, 1L)))
expect_equal(or3s(sfu > 0L, , ),
bor3(sfu > 0L, , ))
expect_equal(or3s(sfv > 1L, , ),
bor3(sfv > 1L, , ))
expect_equal(or3s(sfw > 9L, , ),
bor3(sfw > 9L, , ))
expect_equal(or3s(sfx > 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sfx > 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sfy > 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sfy > 1L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sfz > 9L, , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sfz > 9L, , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sga > 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sga > 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sgb > 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sgb > 1L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sgc > 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sgc > 9L, p %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sgd > 0L, j %in% c(4L, -3L, 2L, 7L, 8L), k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sgd > 0L, j %in% c(4L, -3L, 2L, 7L, 8L), k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sge > 1L, a %in% c(4L, -3L, 2L, 7L, 8L), a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sge > 1L, a %in% c(4L, -3L, 2L, 7L, 8L), a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sgf > 9L, m %in% c(4L, -3L, 2L, 7L, 8L), t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sgf > 9L, m %in% c(4L, -3L, 2L, 7L, 8L), t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sgg > 0L, , ),
bor3(sgg > 0L, , ))
expect_equal(or3s(sgh > 1L, , ),
bor3(sgh > 1L, , ))
expect_equal(or3s(sgi > 9L, , ),
bor3(sgi > 9L, , ))
expect_equal(or3s(sgj > 0L, , s %in% 1:4),
bor3(sgj > 0L, , s %in% 1:4))
expect_equal(or3s(sgk > 1L, , e %in% 1:4),
bor3(sgk > 1L, , e %in% 1:4))
expect_equal(or3s(sgl > 9L, , i %in% 1:4),
bor3(sgl > 9L, , i %in% 1:4))
expect_equal(or3s(sgm > 0L, w %in% 1:4, ),
bor3(sgm > 0L, w %in% 1:4, ))
expect_equal(or3s(sgn > 1L, a %in% 1:4, ),
bor3(sgn > 1L, a %in% 1:4, ))
expect_equal(or3s(sgo > 9L, v %in% 1:4, ),
bor3(sgo > 9L, v %in% 1:4, ))
expect_equal(or3s(sgp > 0L, t %in% 1:4, o %in% 1:4),
bor3(sgp > 0L, t %in% 1:4, o %in% 1:4))
expect_equal(or3s(sgq > 1L, z %in% 1:4, h %in% 1:4),
bor3(sgq > 1L, z %in% 1:4, h %in% 1:4))
expect_equal(or3s(sgr > 9L, m %in% 1:4, i %in% 1:4),
bor3(sgr > 9L, m %in% 1:4, i %in% 1:4))
expect_equal(or3s(sgs > 0L, , ),
bor3(sgs > 0L, , ))
expect_equal(or3s(sgt > 1L, , ),
bor3(sgt > 1L, , ))
expect_equal(or3s(sgu > 9L, , ),
bor3(sgu > 9L, , ))
expect_equal(or3s(sgv > 0L, , k < 0L),
bor3(sgv > 0L, , k < 0L))
expect_equal(or3s(sgw > 1L, , h < 1L),
bor3(sgw > 1L, , h < 1L))
expect_equal(or3s(sgx > 9L, , l < 9L),
bor3(sgx > 9L, , l < 9L))
expect_equal(or3s(sgy > 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sgy > 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sgz > 1L, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sgz > 1L, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sha > 9L, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sha > 9L, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(shb > 0L, s %in% c(4L, -3L, 2L, 7L, 8L), f < 0L),
bor3(shb > 0L, s %in% c(4L, -3L, 2L, 7L, 8L), f < 0L))
expect_equal(or3s(shc > 1L, m %in% c(4L, -3L, 2L, 7L, 8L), o < 1L),
bor3(shc > 1L, m %in% c(4L, -3L, 2L, 7L, 8L), o < 1L))
expect_equal(or3s(shd > 9L, l %in% c(4L, -3L, 2L, 7L, 8L), g < 9L),
bor3(shd > 9L, l %in% c(4L, -3L, 2L, 7L, 8L), g < 9L))
expect_equal(or3s(she > 0L, , ),
bor3(she > 0L, , ))
expect_equal(or3s(shf > 1L, , ),
bor3(shf > 1L, , ))
expect_equal(or3s(shg > 9L, , ),
bor3(shg > 9L, , ))
expect_equal(or3s(shh > 0L, , r < 0L),
bor3(shh > 0L, , r < 0L))
expect_equal(or3s(shi > 1L, , l < 1L),
bor3(shi > 1L, , l < 1L))
expect_equal(or3s(shj > 9L, , t < 9L),
bor3(shj > 9L, , t < 9L))
expect_equal(or3s(shk > 0L, w %in% 1:4, ),
bor3(shk > 0L, w %in% 1:4, ))
expect_equal(or3s(shl > 1L, r %in% 1:4, ),
bor3(shl > 1L, r %in% 1:4, ))
expect_equal(or3s(shm > 9L, i %in% 1:4, ),
bor3(shm > 9L, i %in% 1:4, ))
expect_equal(or3s(shn > 0L, t %in% 1:4, l < 0L),
bor3(shn > 0L, t %in% 1:4, l < 0L))
expect_equal(or3s(sho > 1L, n %in% 1:4, d < 1L),
bor3(sho > 1L, n %in% 1:4, d < 1L))
expect_equal(or3s(shp > 9L, i %in% 1:4, s < 9L),
bor3(shp > 9L, i %in% 1:4, s < 9L))
expect_equal(or3s(shq > 0L, , ),
bor3(shq > 0L, , ))
expect_equal(or3s(shr > 1L, , ),
bor3(shr > 1L, , ))
expect_equal(or3s(shs > 9L, , ),
bor3(shs > 9L, , ))
expect_equal(or3s(sht > 0L, , j <= 0L),
bor3(sht > 0L, , j <= 0L))
expect_equal(or3s(shu > 1L, , r <= 1L),
bor3(shu > 1L, , r <= 1L))
expect_equal(or3s(shv > 9L, , u <= 9L),
bor3(shv > 9L, , u <= 9L))
expect_equal(or3s(shw > 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(shw > 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(shx > 1L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(shx > 1L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(shy > 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(shy > 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(shz > 0L, o %in% c(4L, -3L, 2L, 7L, 8L), p <= 0L),
bor3(shz > 0L, o %in% c(4L, -3L, 2L, 7L, 8L), p <= 0L))
expect_equal(or3s(sia > 1L, u %in% c(4L, -3L, 2L, 7L, 8L), h <= 1L),
bor3(sia > 1L, u %in% c(4L, -3L, 2L, 7L, 8L), h <= 1L))
expect_equal(or3s(sib > 9L, r %in% c(4L, -3L, 2L, 7L, 8L), t <= 9L),
bor3(sib > 9L, r %in% c(4L, -3L, 2L, 7L, 8L), t <= 9L))
expect_equal(or3s(sic > 0L, , ),
bor3(sic > 0L, , ))
expect_equal(or3s(sid > 1L, , ),
bor3(sid > 1L, , ))
expect_equal(or3s(sie > 9L, , ),
bor3(sie > 9L, , ))
expect_equal(or3s(sif > 0L, , s <= 0L),
bor3(sif > 0L, , s <= 0L))
expect_equal(or3s(sig > 1L, , r <= 1L),
bor3(sig > 1L, , r <= 1L))
expect_equal(or3s(sih > 9L, , t <= 9L),
bor3(sih > 9L, , t <= 9L))
expect_equal(or3s(sii > 0L, k %in% 1:4, ),
bor3(sii > 0L, k %in% 1:4, ))
expect_equal(or3s(sij > 1L, g %in% 1:4, ),
bor3(sij > 1L, g %in% 1:4, ))
expect_equal(or3s(sik > 9L, v %in% 1:4, ),
bor3(sik > 9L, v %in% 1:4, ))
expect_equal(or3s(sil > 0L, u %in% 1:4, v <= 0L),
bor3(sil > 0L, u %in% 1:4, v <= 0L))
expect_equal(or3s(sim > 1L, m %in% 1:4, r <= 1L),
bor3(sim > 1L, m %in% 1:4, r <= 1L))
expect_equal(or3s(sin > 9L, k %in% 1:4, t <= 9L),
bor3(sin > 9L, k %in% 1:4, t <= 9L))
expect_equal(or3s(sio > 0L, , ),
bor3(sio > 0L, , ))
expect_equal(or3s(sip > 1L, , ),
bor3(sip > 1L, , ))
expect_equal(or3s(siq > 9L, , ),
bor3(siq > 9L, , ))
expect_equal(or3s(sir > 0L, , h == 0L),
bor3(sir > 0L, , h == 0L))
expect_equal(or3s(sis > 1L, , j == 1L),
bor3(sis > 1L, , j == 1L))
expect_equal(or3s(sit > 9L, , v == 9L),
bor3(sit > 9L, , v == 9L))
expect_equal(or3s(siu > 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(siu > 0L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(siv > 1L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(siv > 1L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(siw > 9L, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(siw > 9L, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(six > 0L, r %in% c(4L, -3L, 2L, 7L, 8L), h == 0L),
bor3(six > 0L, r %in% c(4L, -3L, 2L, 7L, 8L), h == 0L))
expect_equal(or3s(siy > 1L, s %in% c(4L, -3L, 2L, 7L, 8L), a == 1L),
bor3(siy > 1L, s %in% c(4L, -3L, 2L, 7L, 8L), a == 1L))
expect_equal(or3s(siz > 9L, t %in% c(4L, -3L, 2L, 7L, 8L), x == 9L),
bor3(siz > 9L, t %in% c(4L, -3L, 2L, 7L, 8L), x == 9L))
expect_equal(or3s(sja > 0L, , ),
bor3(sja > 0L, , ))
expect_equal(or3s(sjb > 1L, , ),
bor3(sjb > 1L, , ))
expect_equal(or3s(sjc > 9L, , ),
bor3(sjc > 9L, , ))
expect_equal(or3s(sjd > 0L, , v == 0L),
bor3(sjd > 0L, , v == 0L))
expect_equal(or3s(sje > 1L, , s == 1L),
bor3(sje > 1L, , s == 1L))
expect_equal(or3s(sjf > 9L, , k == 9L),
bor3(sjf > 9L, , k == 9L))
expect_equal(or3s(sjg > 0L, i %in% 1:4, ),
bor3(sjg > 0L, i %in% 1:4, ))
expect_equal(or3s(sjh > 1L, h %in% 1:4, ),
bor3(sjh > 1L, h %in% 1:4, ))
expect_equal(or3s(sji > 9L, p %in% 1:4, ),
bor3(sji > 9L, p %in% 1:4, ))
expect_equal(or3s(sjj > 0L, u %in% 1:4, h == 0L),
bor3(sjj > 0L, u %in% 1:4, h == 0L))
expect_equal(or3s(sjk > 1L, r %in% 1:4, l == 1L),
bor3(sjk > 1L, r %in% 1:4, l == 1L))
expect_equal(or3s(sjl > 9L, b %in% 1:4, t == 9L),
bor3(sjl > 9L, b %in% 1:4, t == 9L))
expect_equal(or3s(sjm > 0L, , ),
bor3(sjm > 0L, , ))
expect_equal(or3s(sjn > 1L, , ),
bor3(sjn > 1L, , ))
expect_equal(or3s(sjo > 9L, , ),
bor3(sjo > 9L, , ))
expect_equal(or3s(sjp > 0L, , m > 0L),
bor3(sjp > 0L, , m > 0L))
expect_equal(or3s(sjq > 1L, , f > 1L),
bor3(sjq > 1L, , f > 1L))
expect_equal(or3s(sjr > 9L, , f > 9L),
bor3(sjr > 9L, , f > 9L))
expect_equal(or3s(sjs > 0L, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sjs > 0L, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sjt > 1L, h %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sjt > 1L, h %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sju > 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sju > 9L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sjv > 0L, n %in% c(4L, -3L, 2L, 7L, 8L), s > 0L),
bor3(sjv > 0L, n %in% c(4L, -3L, 2L, 7L, 8L), s > 0L))
expect_equal(or3s(sjw > 1L, b %in% c(4L, -3L, 2L, 7L, 8L), k > 1L),
bor3(sjw > 1L, b %in% c(4L, -3L, 2L, 7L, 8L), k > 1L))
expect_equal(or3s(sjx > 9L, n %in% c(4L, -3L, 2L, 7L, 8L), b > 9L),
bor3(sjx > 9L, n %in% c(4L, -3L, 2L, 7L, 8L), b > 9L))
expect_equal(or3s(sjy > 0L, , ),
bor3(sjy > 0L, , ))
expect_equal(or3s(sjz > 1L, , ),
bor3(sjz > 1L, , ))
expect_equal(or3s(ska > 9L, , ),
bor3(ska > 9L, , ))
expect_equal(or3s(skb > 0L, , m > 0L),
bor3(skb > 0L, , m > 0L))
expect_equal(or3s(skc > 1L, , q > 1L),
bor3(skc > 1L, , q > 1L))
expect_equal(or3s(skd > 9L, , c > 9L),
bor3(skd > 9L, , c > 9L))
expect_equal(or3s(ske > 0L, i %in% 1:4, ),
bor3(ske > 0L, i %in% 1:4, ))
expect_equal(or3s(skf > 1L, q %in% 1:4, ),
bor3(skf > 1L, q %in% 1:4, ))
expect_equal(or3s(skg > 9L, y %in% 1:4, ),
bor3(skg > 9L, y %in% 1:4, ))
expect_equal(or3s(skh > 0L, t %in% 1:4, b > 0L),
bor3(skh > 0L, t %in% 1:4, b > 0L))
expect_equal(or3s(ski > 1L, h %in% 1:4, h > 1L),
bor3(ski > 1L, h %in% 1:4, h > 1L))
expect_equal(or3s(skj > 9L, j %in% 1:4, m > 9L),
bor3(skj > 9L, j %in% 1:4, m > 9L))
expect_equal(or3s(skk > 0L, , ),
bor3(skk > 0L, , ))
expect_equal(or3s(skl > 1L, , ),
bor3(skl > 1L, , ))
expect_equal(or3s(skm > 9L, , ),
bor3(skm > 9L, , ))
expect_equal(or3s(skn > 0L, , i >= 0L),
bor3(skn > 0L, , i >= 0L))
expect_equal(or3s(sko > 1L, , v >= 1L),
bor3(sko > 1L, , v >= 1L))
expect_equal(or3s(skp > 9L, , l >= 9L),
bor3(skp > 9L, , l >= 9L))
expect_equal(or3s(skq > 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(skq > 0L, l %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(skr > 1L, j %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(skr > 1L, j %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(sks > 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(sks > 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(skt > 0L, t %in% c(4L, -3L, 2L, 7L, 8L), g >= 0L),
bor3(skt > 0L, t %in% c(4L, -3L, 2L, 7L, 8L), g >= 0L))
expect_equal(or3s(sku > 1L, s %in% c(4L, -3L, 2L, 7L, 8L), u >= 1L),
bor3(sku > 1L, s %in% c(4L, -3L, 2L, 7L, 8L), u >= 1L))
expect_equal(or3s(skv > 9L, z %in% c(4L, -3L, 2L, 7L, 8L), b >= 9L),
bor3(skv > 9L, z %in% c(4L, -3L, 2L, 7L, 8L), b >= 9L))
expect_equal(or3s(skw > 0L, , ),
bor3(skw > 0L, , ))
expect_equal(or3s(skx > 1L, , ),
bor3(skx > 1L, , ))
expect_equal(or3s(sky > 9L, , ),
bor3(sky > 9L, , ))
expect_equal(or3s(skz > 0L, , m >= 0L),
bor3(skz > 0L, , m >= 0L))
expect_equal(or3s(sla > 1L, , h >= 1L),
bor3(sla > 1L, , h >= 1L))
expect_equal(or3s(slb > 9L, , d >= 9L),
bor3(slb > 9L, , d >= 9L))
expect_equal(or3s(slc > 0L, p %in% 1:4, ),
bor3(slc > 0L, p %in% 1:4, ))
expect_equal(or3s(sld > 1L, z %in% 1:4, ),
bor3(sld > 1L, z %in% 1:4, ))
expect_equal(or3s(sle > 9L, c %in% 1:4, ),
bor3(sle > 9L, c %in% 1:4, ))
expect_equal(or3s(slf > 0L, a %in% 1:4, x >= 0L),
bor3(slf > 0L, a %in% 1:4, x >= 0L))
expect_equal(or3s(slg > 1L, u %in% 1:4, b >= 1L),
bor3(slg > 1L, u %in% 1:4, b >= 1L))
expect_equal(or3s(slh > 9L, v %in% 1:4, x >= 9L),
bor3(slh > 9L, v %in% 1:4, x >= 9L))
expect_equal(or3s(sli > 0L, , ),
bor3(sli > 0L, , ))
expect_equal(or3s(slj > 1L, , ),
bor3(slj > 1L, , ))
expect_equal(or3s(slk > 9L, , ),
bor3(slk > 9L, , ))
expect_equal(or3s(sll > 0L, , logi_f),
bor3(sll > 0L, , logi_f))
expect_equal(or3s(slm > 1L, , logi_b),
bor3(slm > 1L, , logi_b))
expect_equal(or3s(sln > 9L, , logi_w),
bor3(sln > 9L, , logi_w))
expect_equal(or3s(slo > 0L, o < 0L, ),
bor3(slo > 0L, o < 0L, ))
expect_equal(or3s(slp > 1L, e < 1L, ),
bor3(slp > 1L, e < 1L, ))
expect_equal(or3s(slq > 9L, q < 9L, ),
bor3(slq > 9L, q < 9L, ))
expect_equal(or3s(slr > 0L, e < 0L, logi_g),
bor3(slr > 0L, e < 0L, logi_g))
expect_equal(or3s(sls > 1L, b < 1L, logi_j),
bor3(sls > 1L, b < 1L, logi_j))
expect_equal(or3s(slt > 9L, e < 9L, logi_z),
bor3(slt > 9L, e < 9L, logi_z))
expect_equal(or3s(slu > 0L, , ),
bor3(slu > 0L, , ))
expect_equal(or3s(slv > 1L, , ),
bor3(slv > 1L, , ))
expect_equal(or3s(slw > 9L, , ),
bor3(slw > 9L, , ))
expect_equal(or3s(slx > 0L, , !logi_w),
bor3(slx > 0L, , !logi_w))
expect_equal(or3s(sly > 1L, , !logi_b),
bor3(sly > 1L, , !logi_b))
expect_equal(or3s(slz > 9L, , !logi_i),
bor3(slz > 9L, , !logi_i))
expect_equal(or3s(sma > 0L, h < 0L, ),
bor3(sma > 0L, h < 0L, ))
expect_equal(or3s(smb > 1L, p < 1L, ),
bor3(smb > 1L, p < 1L, ))
expect_equal(or3s(smc > 9L, m < 9L, ),
bor3(smc > 9L, m < 9L, ))
expect_equal(or3s(smd > 0L, p < 0L, !logi_p),
bor3(smd > 0L, p < 0L, !logi_p))
expect_equal(or3s(sme > 1L, o < 1L, !logi_u),
bor3(sme > 1L, o < 1L, !logi_u))
expect_equal(or3s(smf > 9L, w < 9L, !logi_n),
bor3(smf > 9L, w < 9L, !logi_n))
expect_equal(or3s(smg > 0L, , ),
bor3(smg > 0L, , ))
expect_equal(or3s(smh > 1L, , ),
bor3(smh > 1L, , ))
expect_equal(or3s(smi > 9L, , ),
bor3(smi > 9L, , ))
expect_equal(or3s(smj > 0L, , a != 0L),
bor3(smj > 0L, , a != 0L))
expect_equal(or3s(smk > 1L, , u != 1L),
bor3(smk > 1L, , u != 1L))
expect_equal(or3s(sml > 9L, , g != 9L),
bor3(sml > 9L, , g != 9L))
expect_equal(or3s(smm > 0L, d < 0L, ),
bor3(smm > 0L, d < 0L, ))
expect_equal(or3s(smn > 1L, i < 1L, ),
bor3(smn > 1L, i < 1L, ))
expect_equal(or3s(smo > 9L, i < 9L, ),
bor3(smo > 9L, i < 9L, ))
expect_equal(or3s(smp > 0L, n < 0L, m != 0L),
bor3(smp > 0L, n < 0L, m != 0L))
expect_equal(or3s(smq > 1L, b < 1L, s != 1L),
bor3(smq > 1L, b < 1L, s != 1L))
expect_equal(or3s(smr > 9L, k < 9L, q != 9L),
bor3(smr > 9L, k < 9L, q != 9L))
expect_equal(or3s(sms > 0L, , ),
bor3(sms > 0L, , ))
expect_equal(or3s(smt > 1L, , ),
bor3(smt > 1L, , ))
expect_equal(or3s(smu > 9L, , ),
bor3(smu > 9L, , ))
expect_equal(or3s(smv > 0L, , k %between% c(-1L, 1L)),
bor3(smv > 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(smw > 1L, , g %between% c(-1L, 1L)),
bor3(smw > 1L, , g %between% c(-1L, 1L)))
expect_equal(or3s(smx > 9L, , z %between% c(-1L, 1L)),
bor3(smx > 9L, , z %between% c(-1L, 1L)))
expect_equal(or3s(smy > 0L, f < 0L, ),
bor3(smy > 0L, f < 0L, ))
expect_equal(or3s(smz > 1L, t < 1L, ),
bor3(smz > 1L, t < 1L, ))
expect_equal(or3s(sna > 9L, f < 9L, ),
bor3(sna > 9L, f < 9L, ))
expect_equal(or3s(snb > 0L, v < 0L, c %between% c(-1L, 1L)),
bor3(snb > 0L, v < 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(snc > 1L, c < 1L, t %between% c(-1L, 1L)),
bor3(snc > 1L, c < 1L, t %between% c(-1L, 1L)))
expect_equal(or3s(snd > 9L, k < 9L, b %between% c(-1L, 1L)),
bor3(snd > 9L, k < 9L, b %between% c(-1L, 1L)))
expect_equal(or3s(sne > 0L, , ),
bor3(sne > 0L, , ))
expect_equal(or3s(snf > 1L, , ),
bor3(snf > 1L, , ))
expect_equal(or3s(sng > 9L, , ),
bor3(sng > 9L, , ))
expect_equal(or3s(snh > 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(snh > 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sni > 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sni > 1L, , c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(snj > 9L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(snj > 9L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(snk > 0L, k < 0L, ),
bor3(snk > 0L, k < 0L, ))
expect_equal(or3s(snl > 1L, g < 1L, ),
bor3(snl > 1L, g < 1L, ))
expect_equal(or3s(snm > 9L, x < 9L, ),
bor3(snm > 9L, x < 9L, ))
expect_equal(or3s(snn > 0L, a < 0L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(snn > 0L, a < 0L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sno > 1L, t < 1L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sno > 1L, t < 1L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(snp > 9L, w < 9L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(snp > 9L, w < 9L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(snq > 0L, , ),
bor3(snq > 0L, , ))
expect_equal(or3s(snr > 1L, , ),
bor3(snr > 1L, , ))
expect_equal(or3s(sns > 9L, , ),
bor3(sns > 9L, , ))
expect_equal(or3s(snt > 0L, , c %in% 1:4),
bor3(snt > 0L, , c %in% 1:4))
expect_equal(or3s(snu > 1L, , o %in% 1:4),
bor3(snu > 1L, , o %in% 1:4))
expect_equal(or3s(snv > 9L, , v %in% 1:4),
bor3(snv > 9L, , v %in% 1:4))
expect_equal(or3s(snw > 0L, t < 0L, ),
bor3(snw > 0L, t < 0L, ))
expect_equal(or3s(snx > 1L, v < 1L, ),
bor3(snx > 1L, v < 1L, ))
expect_equal(or3s(sny > 9L, f < 9L, ),
bor3(sny > 9L, f < 9L, ))
expect_equal(or3s(snz > 0L, z < 0L, u %in% 1:4),
bor3(snz > 0L, z < 0L, u %in% 1:4))
expect_equal(or3s(soa > 1L, e < 1L, h %in% 1:4),
bor3(soa > 1L, e < 1L, h %in% 1:4))
expect_equal(or3s(sob > 9L, l < 9L, a %in% 1:4),
bor3(sob > 9L, l < 9L, a %in% 1:4))
expect_equal(or3s(soc > 0L, , ),
bor3(soc > 0L, , ))
expect_equal(or3s(sod > 1L, , ),
bor3(sod > 1L, , ))
expect_equal(or3s(soe > 9L, , ),
bor3(soe > 9L, , ))
expect_equal(or3s(sof > 0L, , r < 0L),
bor3(sof > 0L, , r < 0L))
expect_equal(or3s(sog > 1L, , f < 1L),
bor3(sog > 1L, , f < 1L))
expect_equal(or3s(soh > 9L, , p < 9L),
bor3(soh > 9L, , p < 9L))
expect_equal(or3s(soi > 0L, e < 0L, ),
bor3(soi > 0L, e < 0L, ))
expect_equal(or3s(soj > 1L, m < 1L, ),
bor3(soj > 1L, m < 1L, ))
expect_equal(or3s(sok > 9L, l < 9L, ),
bor3(sok > 9L, l < 9L, ))
expect_equal(or3s(sol > 0L, l < 0L, o < 0L),
bor3(sol > 0L, l < 0L, o < 0L))
expect_equal(or3s(som > 1L, k < 1L, v < 1L),
bor3(som > 1L, k < 1L, v < 1L))
expect_equal(or3s(son > 9L, u < 9L, s < 9L),
bor3(son > 9L, u < 9L, s < 9L))
expect_equal(or3s(soo > 0L, , ),
bor3(soo > 0L, , ))
expect_equal(or3s(sop > 1L, , ),
bor3(sop > 1L, , ))
expect_equal(or3s(soq > 9L, , ),
bor3(soq > 9L, , ))
expect_equal(or3s(sor > 0L, , t <= 0L),
bor3(sor > 0L, , t <= 0L))
expect_equal(or3s(sos > 1L, , n <= 1L),
bor3(sos > 1L, , n <= 1L))
expect_equal(or3s(sot > 9L, , x <= 9L),
bor3(sot > 9L, , x <= 9L))
expect_equal(or3s(sou > 0L, n < 0L, ),
bor3(sou > 0L, n < 0L, ))
expect_equal(or3s(sov > 1L, o < 1L, ),
bor3(sov > 1L, o < 1L, ))
expect_equal(or3s(sow > 9L, e < 9L, ),
bor3(sow > 9L, e < 9L, ))
expect_equal(or3s(sox > 0L, e < 0L, j <= 0L),
bor3(sox > 0L, e < 0L, j <= 0L))
expect_equal(or3s(soy > 1L, d < 1L, u <= 1L),
bor3(soy > 1L, d < 1L, u <= 1L))
expect_equal(or3s(soz > 9L, f < 9L, o <= 9L),
bor3(soz > 9L, f < 9L, o <= 9L))
expect_equal(or3s(spa > 0L, , ),
bor3(spa > 0L, , ))
expect_equal(or3s(spb > 1L, , ),
bor3(spb > 1L, , ))
expect_equal(or3s(spc > 9L, , ),
bor3(spc > 9L, , ))
expect_equal(or3s(spd > 0L, , p == 0L),
bor3(spd > 0L, , p == 0L))
expect_equal(or3s(spe > 1L, , e == 1L),
bor3(spe > 1L, , e == 1L))
expect_equal(or3s(spf > 9L, , n == 9L),
bor3(spf > 9L, , n == 9L))
expect_equal(or3s(spg > 0L, m < 0L, ),
bor3(spg > 0L, m < 0L, ))
expect_equal(or3s(sph > 1L, y < 1L, ),
bor3(sph > 1L, y < 1L, ))
expect_equal(or3s(spi > 9L, l < 9L, ),
bor3(spi > 9L, l < 9L, ))
expect_equal(or3s(spj > 0L, u < 0L, p == 0L),
bor3(spj > 0L, u < 0L, p == 0L))
expect_equal(or3s(spk > 1L, o < 1L, v == 1L),
bor3(spk > 1L, o < 1L, v == 1L))
expect_equal(or3s(spl > 9L, a < 9L, m == 9L),
bor3(spl > 9L, a < 9L, m == 9L))
expect_equal(or3s(spm > 0L, , ),
bor3(spm > 0L, , ))
expect_equal(or3s(spn > 1L, , ),
bor3(spn > 1L, , ))
expect_equal(or3s(spo > 9L, , ),
bor3(spo > 9L, , ))
expect_equal(or3s(spp > 0L, , r > 0L),
bor3(spp > 0L, , r > 0L))
expect_equal(or3s(spq > 1L, , j > 1L),
bor3(spq > 1L, , j > 1L))
expect_equal(or3s(spr > 9L, , d > 9L),
bor3(spr > 9L, , d > 9L))
expect_equal(or3s(sps > 0L, f < 0L, ),
bor3(sps > 0L, f < 0L, ))
expect_equal(or3s(spt > 1L, t < 1L, ),
bor3(spt > 1L, t < 1L, ))
expect_equal(or3s(spu > 9L, a < 9L, ),
bor3(spu > 9L, a < 9L, ))
expect_equal(or3s(spv > 0L, i < 0L, u > 0L),
bor3(spv > 0L, i < 0L, u > 0L))
expect_equal(or3s(spw > 1L, f < 1L, m > 1L),
bor3(spw > 1L, f < 1L, m > 1L))
expect_equal(or3s(spx > 9L, r < 9L, q > 9L),
bor3(spx > 9L, r < 9L, q > 9L))
expect_equal(or3s(spy > 0L, , ),
bor3(spy > 0L, , ))
expect_equal(or3s(spz > 1L, , ),
bor3(spz > 1L, , ))
expect_equal(or3s(sqa > 9L, , ),
bor3(sqa > 9L, , ))
expect_equal(or3s(sqb > 0L, , c >= 0L),
bor3(sqb > 0L, , c >= 0L))
expect_equal(or3s(sqc > 1L, , m >= 1L),
bor3(sqc > 1L, , m >= 1L))
expect_equal(or3s(sqd > 9L, , c >= 9L),
bor3(sqd > 9L, , c >= 9L))
expect_equal(or3s(sqe > 0L, j < 0L, ),
bor3(sqe > 0L, j < 0L, ))
expect_equal(or3s(sqf > 1L, a < 1L, ),
bor3(sqf > 1L, a < 1L, ))
expect_equal(or3s(sqg > 9L, j < 9L, ),
bor3(sqg > 9L, j < 9L, ))
expect_equal(or3s(sqh > 0L, s < 0L, x >= 0L),
bor3(sqh > 0L, s < 0L, x >= 0L))
expect_equal(or3s(sqi > 1L, s < 1L, s >= 1L),
bor3(sqi > 1L, s < 1L, s >= 1L))
expect_equal(or3s(sqj > 9L, p < 9L, o >= 9L),
bor3(sqj > 9L, p < 9L, o >= 9L))
expect_equal(or3s(sqk > 0L, , ),
bor3(sqk > 0L, , ))
expect_equal(or3s(sql > 1L, , ),
bor3(sql > 1L, , ))
expect_equal(or3s(sqm > 9L, , ),
bor3(sqm > 9L, , ))
expect_equal(or3s(sqn > 0L, , logi_o),
bor3(sqn > 0L, , logi_o))
expect_equal(or3s(sqo > 1L, , logi_z),
bor3(sqo > 1L, , logi_z))
expect_equal(or3s(sqp > 9L, , logi_y),
bor3(sqp > 9L, , logi_y))
expect_equal(or3s(sqq > 0L, p <= 0L, ),
bor3(sqq > 0L, p <= 0L, ))
expect_equal(or3s(sqr > 1L, z <= 1L, ),
bor3(sqr > 1L, z <= 1L, ))
expect_equal(or3s(sqs > 9L, e <= 9L, ),
bor3(sqs > 9L, e <= 9L, ))
expect_equal(or3s(sqt > 0L, d <= 0L, logi_m),
bor3(sqt > 0L, d <= 0L, logi_m))
expect_equal(or3s(squ > 1L, a <= 1L, logi_i),
bor3(squ > 1L, a <= 1L, logi_i))
expect_equal(or3s(sqv > 9L, e <= 9L, logi_h),
bor3(sqv > 9L, e <= 9L, logi_h))
expect_equal(or3s(sqw > 0L, , ),
bor3(sqw > 0L, , ))
expect_equal(or3s(sqx > 1L, , ),
bor3(sqx > 1L, , ))
expect_equal(or3s(sqy > 9L, , ),
bor3(sqy > 9L, , ))
expect_equal(or3s(sqz > 0L, , !logi_h),
bor3(sqz > 0L, , !logi_h))
expect_equal(or3s(sra > 1L, , !logi_p),
bor3(sra > 1L, , !logi_p))
expect_equal(or3s(srb > 9L, , !logi_o),
bor3(srb > 9L, , !logi_o))
expect_equal(or3s(src > 0L, k <= 0L, ),
bor3(src > 0L, k <= 0L, ))
expect_equal(or3s(srd > 1L, x <= 1L, ),
bor3(srd > 1L, x <= 1L, ))
expect_equal(or3s(sre > 9L, z <= 9L, ),
bor3(sre > 9L, z <= 9L, ))
expect_equal(or3s(srf > 0L, b <= 0L, !logi_q),
bor3(srf > 0L, b <= 0L, !logi_q))
expect_equal(or3s(srg > 1L, v <= 1L, !logi_s),
bor3(srg > 1L, v <= 1L, !logi_s))
expect_equal(or3s(srh > 9L, c <= 9L, !logi_d),
bor3(srh > 9L, c <= 9L, !logi_d))
expect_equal(or3s(sri > 0L, , ),
bor3(sri > 0L, , ))
expect_equal(or3s(srj > 1L, , ),
bor3(srj > 1L, , ))
expect_equal(or3s(srk > 9L, , ),
bor3(srk > 9L, , ))
expect_equal(or3s(srl > 0L, , y != 0L),
bor3(srl > 0L, , y != 0L))
expect_equal(or3s(srm > 1L, , e != 1L),
bor3(srm > 1L, , e != 1L))
expect_equal(or3s(srn > 9L, , o != 9L),
bor3(srn > 9L, , o != 9L))
expect_equal(or3s(sro > 0L, c <= 0L, ),
bor3(sro > 0L, c <= 0L, ))
expect_equal(or3s(srp > 1L, j <= 1L, ),
bor3(srp > 1L, j <= 1L, ))
expect_equal(or3s(srq > 9L, w <= 9L, ),
bor3(srq > 9L, w <= 9L, ))
expect_equal(or3s(srr > 0L, z <= 0L, k != 0L),
bor3(srr > 0L, z <= 0L, k != 0L))
expect_equal(or3s(srs > 1L, h <= 1L, q != 1L),
bor3(srs > 1L, h <= 1L, q != 1L))
expect_equal(or3s(srt > 9L, e <= 9L, u != 9L),
bor3(srt > 9L, e <= 9L, u != 9L))
expect_equal(or3s(sru > 0L, , ),
bor3(sru > 0L, , ))
expect_equal(or3s(srv > 1L, , ),
bor3(srv > 1L, , ))
expect_equal(or3s(srw > 9L, , ),
bor3(srw > 9L, , ))
expect_equal(or3s(srx > 0L, , z %between% c(-1L, 1L)),
bor3(srx > 0L, , z %between% c(-1L, 1L)))
expect_equal(or3s(sry > 1L, , g %between% c(-1L, 1L)),
bor3(sry > 1L, , g %between% c(-1L, 1L)))
expect_equal(or3s(srz > 9L, , e %between% c(-1L, 1L)),
bor3(srz > 9L, , e %between% c(-1L, 1L)))
expect_equal(or3s(ssa > 0L, q <= 0L, ),
bor3(ssa > 0L, q <= 0L, ))
expect_equal(or3s(ssb > 1L, l <= 1L, ),
bor3(ssb > 1L, l <= 1L, ))
expect_equal(or3s(ssc > 9L, z <= 9L, ),
bor3(ssc > 9L, z <= 9L, ))
expect_equal(or3s(ssd > 0L, k <= 0L, n %between% c(-1L, 1L)),
bor3(ssd > 0L, k <= 0L, n %between% c(-1L, 1L)))
expect_equal(or3s(sse > 1L, b <= 1L, c %between% c(-1L, 1L)),
bor3(sse > 1L, b <= 1L, c %between% c(-1L, 1L)))
expect_equal(or3s(ssf > 9L, l <= 9L, z %between% c(-1L, 1L)),
bor3(ssf > 9L, l <= 9L, z %between% c(-1L, 1L)))
expect_equal(or3s(ssg > 0L, , ),
bor3(ssg > 0L, , ))
expect_equal(or3s(ssh > 1L, , ),
bor3(ssh > 1L, , ))
expect_equal(or3s(ssi > 9L, , ),
bor3(ssi > 9L, , ))
expect_equal(or3s(ssj > 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ssj > 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ssk > 1L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ssk > 1L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ssl > 9L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ssl > 9L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ssm > 0L, b <= 0L, ),
bor3(ssm > 0L, b <= 0L, ))
expect_equal(or3s(ssn > 1L, e <= 1L, ),
bor3(ssn > 1L, e <= 1L, ))
expect_equal(or3s(sso > 9L, g <= 9L, ),
bor3(sso > 9L, g <= 9L, ))
expect_equal(or3s(ssp > 0L, a <= 0L, p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ssp > 0L, a <= 0L, p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ssq > 1L, k <= 1L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ssq > 1L, k <= 1L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ssr > 9L, u <= 9L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ssr > 9L, u <= 9L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sss > 0L, , ),
bor3(sss > 0L, , ))
expect_equal(or3s(sst > 1L, , ),
bor3(sst > 1L, , ))
expect_equal(or3s(ssu > 9L, , ),
bor3(ssu > 9L, , ))
expect_equal(or3s(ssv > 0L, , s %in% 1:4),
bor3(ssv > 0L, , s %in% 1:4))
expect_equal(or3s(ssw > 1L, , g %in% 1:4),
bor3(ssw > 1L, , g %in% 1:4))
expect_equal(or3s(ssx > 9L, , o %in% 1:4),
bor3(ssx > 9L, , o %in% 1:4))
expect_equal(or3s(ssy > 0L, n <= 0L, ),
bor3(ssy > 0L, n <= 0L, ))
expect_equal(or3s(ssz > 1L, y <= 1L, ),
bor3(ssz > 1L, y <= 1L, ))
expect_equal(or3s(sta > 9L, b <= 9L, ),
bor3(sta > 9L, b <= 9L, ))
expect_equal(or3s(stb > 0L, g <= 0L, o %in% 1:4),
bor3(stb > 0L, g <= 0L, o %in% 1:4))
expect_equal(or3s(stc > 1L, m <= 1L, s %in% 1:4),
bor3(stc > 1L, m <= 1L, s %in% 1:4))
expect_equal(or3s(std > 9L, f <= 9L, m %in% 1:4),
bor3(std > 9L, f <= 9L, m %in% 1:4))
expect_equal(or3s(ste > 0L, , ),
bor3(ste > 0L, , ))
expect_equal(or3s(stf > 1L, , ),
bor3(stf > 1L, , ))
expect_equal(or3s(stg > 9L, , ),
bor3(stg > 9L, , ))
expect_equal(or3s(sth > 0L, , i < 0L),
bor3(sth > 0L, , i < 0L))
expect_equal(or3s(sti > 1L, , j < 1L),
bor3(sti > 1L, , j < 1L))
expect_equal(or3s(stj > 9L, , z < 9L),
bor3(stj > 9L, , z < 9L))
expect_equal(or3s(stk > 0L, z <= 0L, ),
bor3(stk > 0L, z <= 0L, ))
expect_equal(or3s(stl > 1L, t <= 1L, ),
bor3(stl > 1L, t <= 1L, ))
expect_equal(or3s(stm > 9L, f <= 9L, ),
bor3(stm > 9L, f <= 9L, ))
expect_equal(or3s(stn > 0L, r <= 0L, j < 0L),
bor3(stn > 0L, r <= 0L, j < 0L))
expect_equal(or3s(sto > 1L, v <= 1L, i < 1L),
bor3(sto > 1L, v <= 1L, i < 1L))
expect_equal(or3s(stp > 9L, v <= 9L, u < 9L),
bor3(stp > 9L, v <= 9L, u < 9L))
expect_equal(or3s(stq > 0L, , ),
bor3(stq > 0L, , ))
expect_equal(or3s(str > 1L, , ),
bor3(str > 1L, , ))
expect_equal(or3s(sts > 9L, , ),
bor3(sts > 9L, , ))
expect_equal(or3s(stt > 0L, , f <= 0L),
bor3(stt > 0L, , f <= 0L))
expect_equal(or3s(stu > 1L, , r <= 1L),
bor3(stu > 1L, , r <= 1L))
expect_equal(or3s(stv > 9L, , h <= 9L),
bor3(stv > 9L, , h <= 9L))
expect_equal(or3s(stw > 0L, c <= 0L, ),
bor3(stw > 0L, c <= 0L, ))
expect_equal(or3s(stx > 1L, m <= 1L, ),
bor3(stx > 1L, m <= 1L, ))
expect_equal(or3s(sty > 9L, k <= 9L, ),
bor3(sty > 9L, k <= 9L, ))
expect_equal(or3s(stz > 0L, c <= 0L, l <= 0L),
bor3(stz > 0L, c <= 0L, l <= 0L))
expect_equal(or3s(sua > 1L, v <= 1L, v <= 1L),
bor3(sua > 1L, v <= 1L, v <= 1L))
expect_equal(or3s(sub > 9L, k <= 9L, y <= 9L),
bor3(sub > 9L, k <= 9L, y <= 9L))
expect_equal(or3s(suc > 0L, , ),
bor3(suc > 0L, , ))
expect_equal(or3s(sud > 1L, , ),
bor3(sud > 1L, , ))
expect_equal(or3s(sue > 9L, , ),
bor3(sue > 9L, , ))
expect_equal(or3s(suf > 0L, , w == 0L),
bor3(suf > 0L, , w == 0L))
expect_equal(or3s(sug > 1L, , t == 1L),
bor3(sug > 1L, , t == 1L))
expect_equal(or3s(suh > 9L, , p == 9L),
bor3(suh > 9L, , p == 9L))
expect_equal(or3s(sui > 0L, n <= 0L, ),
bor3(sui > 0L, n <= 0L, ))
expect_equal(or3s(suj > 1L, s <= 1L, ),
bor3(suj > 1L, s <= 1L, ))
expect_equal(or3s(suk > 9L, i <= 9L, ),
bor3(suk > 9L, i <= 9L, ))
expect_equal(or3s(sul > 0L, q <= 0L, a == 0L),
bor3(sul > 0L, q <= 0L, a == 0L))
expect_equal(or3s(sum > 1L, d <= 1L, t == 1L),
bor3(sum > 1L, d <= 1L, t == 1L))
expect_equal(or3s(sun > 9L, q <= 9L, c == 9L),
bor3(sun > 9L, q <= 9L, c == 9L))
expect_equal(or3s(suo > 0L, , ),
bor3(suo > 0L, , ))
expect_equal(or3s(sup > 1L, , ),
bor3(sup > 1L, , ))
expect_equal(or3s(suq > 9L, , ),
bor3(suq > 9L, , ))
expect_equal(or3s(sur > 0L, , t > 0L),
bor3(sur > 0L, , t > 0L))
expect_equal(or3s(sus > 1L, , g > 1L),
bor3(sus > 1L, , g > 1L))
expect_equal(or3s(sut > 9L, , h > 9L),
bor3(sut > 9L, , h > 9L))
expect_equal(or3s(suu > 0L, c <= 0L, ),
bor3(suu > 0L, c <= 0L, ))
expect_equal(or3s(suv > 1L, w <= 1L, ),
bor3(suv > 1L, w <= 1L, ))
expect_equal(or3s(suw > 9L, o <= 9L, ),
bor3(suw > 9L, o <= 9L, ))
expect_equal(or3s(sux > 0L, j <= 0L, h > 0L),
bor3(sux > 0L, j <= 0L, h > 0L))
expect_equal(or3s(suy > 1L, o <= 1L, a > 1L),
bor3(suy > 1L, o <= 1L, a > 1L))
expect_equal(or3s(suz > 9L, y <= 9L, d > 9L),
bor3(suz > 9L, y <= 9L, d > 9L))
expect_equal(or3s(sva > 0L, , ),
bor3(sva > 0L, , ))
expect_equal(or3s(svb > 1L, , ),
bor3(svb > 1L, , ))
expect_equal(or3s(svc > 9L, , ),
bor3(svc > 9L, , ))
expect_equal(or3s(svd > 0L, , j >= 0L),
bor3(svd > 0L, , j >= 0L))
expect_equal(or3s(sve > 1L, , r >= 1L),
bor3(sve > 1L, , r >= 1L))
expect_equal(or3s(svf > 9L, , p >= 9L),
bor3(svf > 9L, , p >= 9L))
expect_equal(or3s(svg > 0L, a <= 0L, ),
bor3(svg > 0L, a <= 0L, ))
expect_equal(or3s(svh > 1L, x <= 1L, ),
bor3(svh > 1L, x <= 1L, ))
expect_equal(or3s(svi > 9L, o <= 9L, ),
bor3(svi > 9L, o <= 9L, ))
expect_equal(or3s(svj > 0L, l <= 0L, d >= 0L),
bor3(svj > 0L, l <= 0L, d >= 0L))
expect_equal(or3s(svk > 1L, h <= 1L, g >= 1L),
bor3(svk > 1L, h <= 1L, g >= 1L))
expect_equal(or3s(svl > 9L, g <= 9L, f >= 9L),
bor3(svl > 9L, g <= 9L, f >= 9L))
expect_equal(or3s(svm > 0L, , ),
bor3(svm > 0L, , ))
expect_equal(or3s(svn > 1L, , ),
bor3(svn > 1L, , ))
expect_equal(or3s(svo > 9L, , ),
bor3(svo > 9L, , ))
expect_equal(or3s(svp > 0L, , logi_u),
bor3(svp > 0L, , logi_u))
expect_equal(or3s(svq > 1L, , logi_j),
bor3(svq > 1L, , logi_j))
expect_equal(or3s(svr > 9L, , logi_b),
bor3(svr > 9L, , logi_b))
expect_equal(or3s(svs > 0L, l == 0L, ),
bor3(svs > 0L, l == 0L, ))
expect_equal(or3s(svt > 1L, i == 1L, ),
bor3(svt > 1L, i == 1L, ))
expect_equal(or3s(svu > 9L, y == 9L, ),
bor3(svu > 9L, y == 9L, ))
expect_equal(or3s(svv > 0L, q == 0L, logi_a),
bor3(svv > 0L, q == 0L, logi_a))
expect_equal(or3s(svw > 1L, l == 1L, logi_f),
bor3(svw > 1L, l == 1L, logi_f))
expect_equal(or3s(svx > 9L, q == 9L, logi_l),
bor3(svx > 9L, q == 9L, logi_l))
expect_equal(or3s(svy > 0L, , ),
bor3(svy > 0L, , ))
expect_equal(or3s(svz > 1L, , ),
bor3(svz > 1L, , ))
expect_equal(or3s(swa > 9L, , ),
bor3(swa > 9L, , ))
expect_equal(or3s(swb > 0L, , !logi_b),
bor3(swb > 0L, , !logi_b))
expect_equal(or3s(swc > 1L, , !logi_i),
bor3(swc > 1L, , !logi_i))
expect_equal(or3s(swd > 9L, , !logi_e),
bor3(swd > 9L, , !logi_e))
expect_equal(or3s(swe > 0L, j == 0L, ),
bor3(swe > 0L, j == 0L, ))
expect_equal(or3s(swf > 1L, r == 1L, ),
bor3(swf > 1L, r == 1L, ))
expect_equal(or3s(swg > 9L, y == 9L, ),
bor3(swg > 9L, y == 9L, ))
expect_equal(or3s(swh > 0L, m == 0L, !logi_q),
bor3(swh > 0L, m == 0L, !logi_q))
expect_equal(or3s(swi > 1L, n == 1L, !logi_a),
bor3(swi > 1L, n == 1L, !logi_a))
expect_equal(or3s(swj > 9L, x == 9L, !logi_n),
bor3(swj > 9L, x == 9L, !logi_n))
expect_equal(or3s(swk > 0L, , ),
bor3(swk > 0L, , ))
expect_equal(or3s(swl > 1L, , ),
bor3(swl > 1L, , ))
expect_equal(or3s(swm > 9L, , ),
bor3(swm > 9L, , ))
expect_equal(or3s(swn > 0L, , z != 0L),
bor3(swn > 0L, , z != 0L))
expect_equal(or3s(swo > 1L, , e != 1L),
bor3(swo > 1L, , e != 1L))
expect_equal(or3s(swp > 9L, , f != 9L),
bor3(swp > 9L, , f != 9L))
expect_equal(or3s(swq > 0L, s == 0L, ),
bor3(swq > 0L, s == 0L, ))
expect_equal(or3s(swr > 1L, v == 1L, ),
bor3(swr > 1L, v == 1L, ))
expect_equal(or3s(sws > 9L, p == 9L, ),
bor3(sws > 9L, p == 9L, ))
expect_equal(or3s(swt > 0L, e == 0L, r != 0L),
bor3(swt > 0L, e == 0L, r != 0L))
expect_equal(or3s(swu > 1L, q == 1L, b != 1L),
bor3(swu > 1L, q == 1L, b != 1L))
expect_equal(or3s(swv > 9L, d == 9L, o != 9L),
bor3(swv > 9L, d == 9L, o != 9L))
expect_equal(or3s(sww > 0L, , ),
bor3(sww > 0L, , ))
expect_equal(or3s(swx > 1L, , ),
bor3(swx > 1L, , ))
expect_equal(or3s(swy > 9L, , ),
bor3(swy > 9L, , ))
expect_equal(or3s(swz > 0L, , g %between% c(-1L, 1L)),
bor3(swz > 0L, , g %between% c(-1L, 1L)))
expect_equal(or3s(sxa > 1L, , h %between% c(-1L, 1L)),
bor3(sxa > 1L, , h %between% c(-1L, 1L)))
expect_equal(or3s(sxb > 9L, , l %between% c(-1L, 1L)),
bor3(sxb > 9L, , l %between% c(-1L, 1L)))
expect_equal(or3s(sxc > 0L, i == 0L, ),
bor3(sxc > 0L, i == 0L, ))
expect_equal(or3s(sxd > 1L, g == 1L, ),
bor3(sxd > 1L, g == 1L, ))
expect_equal(or3s(sxe > 9L, k == 9L, ),
bor3(sxe > 9L, k == 9L, ))
expect_equal(or3s(sxf > 0L, t == 0L, h %between% c(-1L, 1L)),
bor3(sxf > 0L, t == 0L, h %between% c(-1L, 1L)))
expect_equal(or3s(sxg > 1L, q == 1L, q %between% c(-1L, 1L)),
bor3(sxg > 1L, q == 1L, q %between% c(-1L, 1L)))
expect_equal(or3s(sxh > 9L, n == 9L, x %between% c(-1L, 1L)),
bor3(sxh > 9L, n == 9L, x %between% c(-1L, 1L)))
expect_equal(or3s(sxi > 0L, , ),
bor3(sxi > 0L, , ))
expect_equal(or3s(sxj > 1L, , ),
bor3(sxj > 1L, , ))
expect_equal(or3s(sxk > 9L, , ),
bor3(sxk > 9L, , ))
expect_equal(or3s(sxl > 0L, , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sxl > 0L, , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sxm > 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sxm > 1L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sxn > 9L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sxn > 9L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sxo > 0L, k == 0L, ),
bor3(sxo > 0L, k == 0L, ))
expect_equal(or3s(sxp > 1L, y == 1L, ),
bor3(sxp > 1L, y == 1L, ))
expect_equal(or3s(sxq > 9L, a == 9L, ),
bor3(sxq > 9L, a == 9L, ))
expect_equal(or3s(sxr > 0L, h == 0L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sxr > 0L, h == 0L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sxs > 1L, o == 1L, s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sxs > 1L, o == 1L, s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sxt > 9L, p == 9L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(sxt > 9L, p == 9L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(sxu > 0L, , ),
bor3(sxu > 0L, , ))
expect_equal(or3s(sxv > 1L, , ),
bor3(sxv > 1L, , ))
expect_equal(or3s(sxw > 9L, , ),
bor3(sxw > 9L, , ))
expect_equal(or3s(sxx > 0L, , e %in% 1:4),
bor3(sxx > 0L, , e %in% 1:4))
expect_equal(or3s(sxy > 1L, , t %in% 1:4),
bor3(sxy > 1L, , t %in% 1:4))
expect_equal(or3s(sxz > 9L, , s %in% 1:4),
bor3(sxz > 9L, , s %in% 1:4))
expect_equal(or3s(sya > 0L, i == 0L, ),
bor3(sya > 0L, i == 0L, ))
expect_equal(or3s(syb > 1L, l == 1L, ),
bor3(syb > 1L, l == 1L, ))
expect_equal(or3s(syc > 9L, j == 9L, ),
bor3(syc > 9L, j == 9L, ))
expect_equal(or3s(syd > 0L, y == 0L, a %in% 1:4),
bor3(syd > 0L, y == 0L, a %in% 1:4))
expect_equal(or3s(sye > 1L, k == 1L, m %in% 1:4),
bor3(sye > 1L, k == 1L, m %in% 1:4))
expect_equal(or3s(syf > 9L, f == 9L, v %in% 1:4),
bor3(syf > 9L, f == 9L, v %in% 1:4))
expect_equal(or3s(syg > 0L, , ),
bor3(syg > 0L, , ))
expect_equal(or3s(syh > 1L, , ),
bor3(syh > 1L, , ))
expect_equal(or3s(syi > 9L, , ),
bor3(syi > 9L, , ))
expect_equal(or3s(syj > 0L, , n < 0L),
bor3(syj > 0L, , n < 0L))
expect_equal(or3s(syk > 1L, , r < 1L),
bor3(syk > 1L, , r < 1L))
expect_equal(or3s(syl > 9L, , g < 9L),
bor3(syl > 9L, , g < 9L))
expect_equal(or3s(sym > 0L, l == 0L, ),
bor3(sym > 0L, l == 0L, ))
expect_equal(or3s(syn > 1L, x == 1L, ),
bor3(syn > 1L, x == 1L, ))
expect_equal(or3s(syo > 9L, e == 9L, ),
bor3(syo > 9L, e == 9L, ))
expect_equal(or3s(syp > 0L, z == 0L, d < 0L),
bor3(syp > 0L, z == 0L, d < 0L))
expect_equal(or3s(syq > 1L, l == 1L, c < 1L),
bor3(syq > 1L, l == 1L, c < 1L))
expect_equal(or3s(syr > 9L, i == 9L, x < 9L),
bor3(syr > 9L, i == 9L, x < 9L))
expect_equal(or3s(sys > 0L, , ),
bor3(sys > 0L, , ))
expect_equal(or3s(syt > 1L, , ),
bor3(syt > 1L, , ))
expect_equal(or3s(syu > 9L, , ),
bor3(syu > 9L, , ))
expect_equal(or3s(syv > 0L, , o <= 0L),
bor3(syv > 0L, , o <= 0L))
expect_equal(or3s(syw > 1L, , w <= 1L),
bor3(syw > 1L, , w <= 1L))
expect_equal(or3s(syx > 9L, , l <= 9L),
bor3(syx > 9L, , l <= 9L))
expect_equal(or3s(syy > 0L, d == 0L, ),
bor3(syy > 0L, d == 0L, ))
expect_equal(or3s(syz > 1L, q == 1L, ),
bor3(syz > 1L, q == 1L, ))
expect_equal(or3s(ta > 9L, s == 9L, ),
bor3(ta > 9L, s == 9L, ))
expect_equal(or3s(tb > 0L, i == 0L, i <= 0L),
bor3(tb > 0L, i == 0L, i <= 0L))
expect_equal(or3s(tc > 1L, j == 1L, c <= 1L),
bor3(tc > 1L, j == 1L, c <= 1L))
expect_equal(or3s(td > 9L, k == 9L, c <= 9L),
bor3(td > 9L, k == 9L, c <= 9L))
expect_equal(or3s(te > 0L, , ),
bor3(te > 0L, , ))
expect_equal(or3s(tf > 1L, , ),
bor3(tf > 1L, , ))
expect_equal(or3s(tg > 9L, , ),
bor3(tg > 9L, , ))
expect_equal(or3s(th > 0L, , t == 0L),
bor3(th > 0L, , t == 0L))
expect_equal(or3s(ti > 1L, , h == 1L),
bor3(ti > 1L, , h == 1L))
expect_equal(or3s(tj > 9L, , l == 9L),
bor3(tj > 9L, , l == 9L))
expect_equal(or3s(tk > 0L, n == 0L, ),
bor3(tk > 0L, n == 0L, ))
expect_equal(or3s(tl > 1L, m == 1L, ),
bor3(tl > 1L, m == 1L, ))
expect_equal(or3s(tm > 9L, w == 9L, ),
bor3(tm > 9L, w == 9L, ))
expect_equal(or3s(tn > 0L, j == 0L, m == 0L),
bor3(tn > 0L, j == 0L, m == 0L))
expect_equal(or3s(to > 1L, b == 1L, w == 1L),
bor3(to > 1L, b == 1L, w == 1L))
expect_equal(or3s(tp > 9L, i == 9L, q == 9L),
bor3(tp > 9L, i == 9L, q == 9L))
expect_equal(or3s(tq > 0L, , ),
bor3(tq > 0L, , ))
expect_equal(or3s(tr > 1L, , ),
bor3(tr > 1L, , ))
expect_equal(or3s(ts > 9L, , ),
bor3(ts > 9L, , ))
expect_equal(or3s(tt > 0L, , k > 0L),
bor3(tt > 0L, , k > 0L))
expect_equal(or3s(tu > 1L, , z > 1L),
bor3(tu > 1L, , z > 1L))
expect_equal(or3s(tv > 9L, , h > 9L),
bor3(tv > 9L, , h > 9L))
expect_equal(or3s(tw > 0L, b == 0L, ),
bor3(tw > 0L, b == 0L, ))
expect_equal(or3s(tx > 1L, k == 1L, ),
bor3(tx > 1L, k == 1L, ))
expect_equal(or3s(ty > 9L, r == 9L, ),
bor3(ty > 9L, r == 9L, ))
expect_equal(or3s(tz > 0L, l == 0L, x > 0L),
bor3(tz > 0L, l == 0L, x > 0L))
expect_equal(or3s(taa > 1L, d == 1L, n > 1L),
bor3(taa > 1L, d == 1L, n > 1L))
expect_equal(or3s(tab > 9L, f == 9L, m > 9L),
bor3(tab > 9L, f == 9L, m > 9L))
expect_equal(or3s(tac > 0L, , ),
bor3(tac > 0L, , ))
expect_equal(or3s(tad > 1L, , ),
bor3(tad > 1L, , ))
expect_equal(or3s(tae > 9L, , ),
bor3(tae > 9L, , ))
expect_equal(or3s(taf > 0L, , b >= 0L),
bor3(taf > 0L, , b >= 0L))
expect_equal(or3s(tag > 1L, , p >= 1L),
bor3(tag > 1L, , p >= 1L))
expect_equal(or3s(tah > 9L, , v >= 9L),
bor3(tah > 9L, , v >= 9L))
expect_equal(or3s(tai > 0L, j == 0L, ),
bor3(tai > 0L, j == 0L, ))
expect_equal(or3s(taj > 1L, v == 1L, ),
bor3(taj > 1L, v == 1L, ))
expect_equal(or3s(tak > 9L, g == 9L, ),
bor3(tak > 9L, g == 9L, ))
expect_equal(or3s(tal > 0L, p == 0L, d >= 0L),
bor3(tal > 0L, p == 0L, d >= 0L))
expect_equal(or3s(tam > 1L, o == 1L, u >= 1L),
bor3(tam > 1L, o == 1L, u >= 1L))
expect_equal(or3s(tan > 9L, j == 9L, n >= 9L),
bor3(tan > 9L, j == 9L, n >= 9L))
expect_equal(or3s(tao > 0L, , ),
bor3(tao > 0L, , ))
expect_equal(or3s(tap > 1L, , ),
bor3(tap > 1L, , ))
expect_equal(or3s(taq > 9L, , ),
bor3(taq > 9L, , ))
expect_equal(or3s(tar > 0L, , logi_l),
bor3(tar > 0L, , logi_l))
expect_equal(or3s(tas > 1L, , logi_v),
bor3(tas > 1L, , logi_v))
expect_equal(or3s(tat > 9L, , logi_r),
bor3(tat > 9L, , logi_r))
expect_equal(or3s(tau > 0L, w > 0L, ),
bor3(tau > 0L, w > 0L, ))
expect_equal(or3s(tav > 1L, o > 1L, ),
bor3(tav > 1L, o > 1L, ))
expect_equal(or3s(taw > 9L, d > 9L, ),
bor3(taw > 9L, d > 9L, ))
expect_equal(or3s(tax > 0L, s > 0L, logi_i),
bor3(tax > 0L, s > 0L, logi_i))
expect_equal(or3s(tay > 1L, x > 1L, logi_k),
bor3(tay > 1L, x > 1L, logi_k))
expect_equal(or3s(taz > 9L, l > 9L, logi_w),
bor3(taz > 9L, l > 9L, logi_w))
expect_equal(or3s(tba > 0L, , ),
bor3(tba > 0L, , ))
expect_equal(or3s(tbb > 1L, , ),
bor3(tbb > 1L, , ))
expect_equal(or3s(tbc > 9L, , ),
bor3(tbc > 9L, , ))
expect_equal(or3s(tbd > 0L, , !logi_r),
bor3(tbd > 0L, , !logi_r))
expect_equal(or3s(tbe > 1L, , !logi_l),
bor3(tbe > 1L, , !logi_l))
expect_equal(or3s(tbf > 9L, , !logi_w),
bor3(tbf > 9L, , !logi_w))
expect_equal(or3s(tbg > 0L, w > 0L, ),
bor3(tbg > 0L, w > 0L, ))
expect_equal(or3s(tbh > 1L, g > 1L, ),
bor3(tbh > 1L, g > 1L, ))
expect_equal(or3s(tbi > 9L, c > 9L, ),
bor3(tbi > 9L, c > 9L, ))
expect_equal(or3s(tbj > 0L, w > 0L, !logi_l),
bor3(tbj > 0L, w > 0L, !logi_l))
expect_equal(or3s(tbk > 1L, v > 1L, !logi_f),
bor3(tbk > 1L, v > 1L, !logi_f))
expect_equal(or3s(tbl > 9L, c > 9L, !logi_c),
bor3(tbl > 9L, c > 9L, !logi_c))
expect_equal(or3s(tbm > 0L, , ),
bor3(tbm > 0L, , ))
expect_equal(or3s(tbn > 1L, , ),
bor3(tbn > 1L, , ))
expect_equal(or3s(tbo > 9L, , ),
bor3(tbo > 9L, , ))
expect_equal(or3s(tbp > 0L, , m != 0L),
bor3(tbp > 0L, , m != 0L))
expect_equal(or3s(tbq > 1L, , v != 1L),
bor3(tbq > 1L, , v != 1L))
expect_equal(or3s(tbr > 9L, , z != 9L),
bor3(tbr > 9L, , z != 9L))
expect_equal(or3s(tbs > 0L, n > 0L, ),
bor3(tbs > 0L, n > 0L, ))
expect_equal(or3s(tbt > 1L, u > 1L, ),
bor3(tbt > 1L, u > 1L, ))
expect_equal(or3s(tbu > 9L, i > 9L, ),
bor3(tbu > 9L, i > 9L, ))
expect_equal(or3s(tbv > 0L, l > 0L, s != 0L),
bor3(tbv > 0L, l > 0L, s != 0L))
expect_equal(or3s(tbw > 1L, m > 1L, l != 1L),
bor3(tbw > 1L, m > 1L, l != 1L))
expect_equal(or3s(tbx > 9L, q > 9L, l != 9L),
bor3(tbx > 9L, q > 9L, l != 9L))
expect_equal(or3s(tby > 0L, , ),
bor3(tby > 0L, , ))
expect_equal(or3s(tbz > 1L, , ),
bor3(tbz > 1L, , ))
expect_equal(or3s(tca > 9L, , ),
bor3(tca > 9L, , ))
expect_equal(or3s(tcb > 0L, , k %between% c(-1L, 1L)),
bor3(tcb > 0L, , k %between% c(-1L, 1L)))
expect_equal(or3s(tcc > 1L, , l %between% c(-1L, 1L)),
bor3(tcc > 1L, , l %between% c(-1L, 1L)))
expect_equal(or3s(tcd > 9L, , x %between% c(-1L, 1L)),
bor3(tcd > 9L, , x %between% c(-1L, 1L)))
expect_equal(or3s(tce > 0L, q > 0L, ),
bor3(tce > 0L, q > 0L, ))
expect_equal(or3s(tcf > 1L, t > 1L, ),
bor3(tcf > 1L, t > 1L, ))
expect_equal(or3s(tcg > 9L, q > 9L, ),
bor3(tcg > 9L, q > 9L, ))
expect_equal(or3s(tch > 0L, k > 0L, e %between% c(-1L, 1L)),
bor3(tch > 0L, k > 0L, e %between% c(-1L, 1L)))
expect_equal(or3s(tci > 1L, a > 1L, r %between% c(-1L, 1L)),
bor3(tci > 1L, a > 1L, r %between% c(-1L, 1L)))
expect_equal(or3s(tcj > 9L, v > 9L, j %between% c(-1L, 1L)),
bor3(tcj > 9L, v > 9L, j %between% c(-1L, 1L)))
expect_equal(or3s(tck > 0L, , ),
bor3(tck > 0L, , ))
expect_equal(or3s(tcl > 1L, , ),
bor3(tcl > 1L, , ))
expect_equal(or3s(tcm > 9L, , ),
bor3(tcm > 9L, , ))
expect_equal(or3s(tcn > 0L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tcn > 0L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tco > 1L, , f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tco > 1L, , f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tcp > 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tcp > 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tcq > 0L, w > 0L, ),
bor3(tcq > 0L, w > 0L, ))
expect_equal(or3s(tcr > 1L, m > 1L, ),
bor3(tcr > 1L, m > 1L, ))
expect_equal(or3s(tcs > 9L, z > 9L, ),
bor3(tcs > 9L, z > 9L, ))
expect_equal(or3s(tct > 0L, t > 0L, j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tct > 0L, t > 0L, j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tcu > 1L, c > 1L, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tcu > 1L, c > 1L, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tcv > 9L, w > 9L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tcv > 9L, w > 9L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tcw > 0L, , ),
bor3(tcw > 0L, , ))
expect_equal(or3s(tcx > 1L, , ),
bor3(tcx > 1L, , ))
expect_equal(or3s(tcy > 9L, , ),
bor3(tcy > 9L, , ))
expect_equal(or3s(tcz > 0L, , f %in% 1:4),
bor3(tcz > 0L, , f %in% 1:4))
expect_equal(or3s(tda > 1L, , f %in% 1:4),
bor3(tda > 1L, , f %in% 1:4))
expect_equal(or3s(tdb > 9L, , z %in% 1:4),
bor3(tdb > 9L, , z %in% 1:4))
expect_equal(or3s(tdc > 0L, e > 0L, ),
bor3(tdc > 0L, e > 0L, ))
expect_equal(or3s(tdd > 1L, i > 1L, ),
bor3(tdd > 1L, i > 1L, ))
expect_equal(or3s(tde > 9L, q > 9L, ),
bor3(tde > 9L, q > 9L, ))
expect_equal(or3s(tdf > 0L, v > 0L, o %in% 1:4),
bor3(tdf > 0L, v > 0L, o %in% 1:4))
expect_equal(or3s(tdg > 1L, j > 1L, d %in% 1:4),
bor3(tdg > 1L, j > 1L, d %in% 1:4))
expect_equal(or3s(tdh > 9L, r > 9L, l %in% 1:4),
bor3(tdh > 9L, r > 9L, l %in% 1:4))
expect_equal(or3s(tdi > 0L, , ),
bor3(tdi > 0L, , ))
expect_equal(or3s(tdj > 1L, , ),
bor3(tdj > 1L, , ))
expect_equal(or3s(tdk > 9L, , ),
bor3(tdk > 9L, , ))
expect_equal(or3s(tdl > 0L, , s < 0L),
bor3(tdl > 0L, , s < 0L))
expect_equal(or3s(tdm > 1L, , r < 1L),
bor3(tdm > 1L, , r < 1L))
expect_equal(or3s(tdn > 9L, , l < 9L),
bor3(tdn > 9L, , l < 9L))
expect_equal(or3s(tdo > 0L, r > 0L, ),
bor3(tdo > 0L, r > 0L, ))
expect_equal(or3s(tdp > 1L, m > 1L, ),
bor3(tdp > 1L, m > 1L, ))
expect_equal(or3s(tdq > 9L, r > 9L, ),
bor3(tdq > 9L, r > 9L, ))
expect_equal(or3s(tdr > 0L, q > 0L, b < 0L),
bor3(tdr > 0L, q > 0L, b < 0L))
expect_equal(or3s(tds > 1L, b > 1L, m < 1L),
bor3(tds > 1L, b > 1L, m < 1L))
expect_equal(or3s(tdt > 9L, s > 9L, u < 9L),
bor3(tdt > 9L, s > 9L, u < 9L))
expect_equal(or3s(tdu > 0L, , ),
bor3(tdu > 0L, , ))
expect_equal(or3s(tdv > 1L, , ),
bor3(tdv > 1L, , ))
expect_equal(or3s(tdw > 9L, , ),
bor3(tdw > 9L, , ))
expect_equal(or3s(tdx > 0L, , q <= 0L),
bor3(tdx > 0L, , q <= 0L))
expect_equal(or3s(tdy > 1L, , n <= 1L),
bor3(tdy > 1L, , n <= 1L))
expect_equal(or3s(tdz > 9L, , q <= 9L),
bor3(tdz > 9L, , q <= 9L))
expect_equal(or3s(tea > 0L, n > 0L, ),
bor3(tea > 0L, n > 0L, ))
expect_equal(or3s(teb > 1L, y > 1L, ),
bor3(teb > 1L, y > 1L, ))
expect_equal(or3s(tec > 9L, a > 9L, ),
bor3(tec > 9L, a > 9L, ))
expect_equal(or3s(ted > 0L, j > 0L, s <= 0L),
bor3(ted > 0L, j > 0L, s <= 0L))
expect_equal(or3s(tee > 1L, k > 1L, b <= 1L),
bor3(tee > 1L, k > 1L, b <= 1L))
expect_equal(or3s(tef > 9L, d > 9L, w <= 9L),
bor3(tef > 9L, d > 9L, w <= 9L))
expect_equal(or3s(teg > 0L, , ),
bor3(teg > 0L, , ))
expect_equal(or3s(teh > 1L, , ),
bor3(teh > 1L, , ))
expect_equal(or3s(tei > 9L, , ),
bor3(tei > 9L, , ))
expect_equal(or3s(tej > 0L, , m == 0L),
bor3(tej > 0L, , m == 0L))
expect_equal(or3s(tek > 1L, , p == 1L),
bor3(tek > 1L, , p == 1L))
expect_equal(or3s(tel > 9L, , u == 9L),
bor3(tel > 9L, , u == 9L))
expect_equal(or3s(tem > 0L, g > 0L, ),
bor3(tem > 0L, g > 0L, ))
expect_equal(or3s(ten > 1L, n > 1L, ),
bor3(ten > 1L, n > 1L, ))
expect_equal(or3s(teo > 9L, c > 9L, ),
bor3(teo > 9L, c > 9L, ))
expect_equal(or3s(tep > 0L, p > 0L, h == 0L),
bor3(tep > 0L, p > 0L, h == 0L))
expect_equal(or3s(teq > 1L, u > 1L, b == 1L),
bor3(teq > 1L, u > 1L, b == 1L))
expect_equal(or3s(ter > 9L, i > 9L, u == 9L),
bor3(ter > 9L, i > 9L, u == 9L))
expect_equal(or3s(tes > 0L, , ),
bor3(tes > 0L, , ))
expect_equal(or3s(tet > 1L, , ),
bor3(tet > 1L, , ))
expect_equal(or3s(teu > 9L, , ),
bor3(teu > 9L, , ))
expect_equal(or3s(tev > 0L, , o > 0L),
bor3(tev > 0L, , o > 0L))
expect_equal(or3s(tew > 1L, , y > 1L),
bor3(tew > 1L, , y > 1L))
expect_equal(or3s(tex > 9L, , g > 9L),
bor3(tex > 9L, , g > 9L))
expect_equal(or3s(tey > 0L, v > 0L, ),
bor3(tey > 0L, v > 0L, ))
expect_equal(or3s(tez > 1L, e > 1L, ),
bor3(tez > 1L, e > 1L, ))
expect_equal(or3s(tfa > 9L, v > 9L, ),
bor3(tfa > 9L, v > 9L, ))
expect_equal(or3s(tfb > 0L, k > 0L, j > 0L),
bor3(tfb > 0L, k > 0L, j > 0L))
expect_equal(or3s(tfc > 1L, n > 1L, j > 1L),
bor3(tfc > 1L, n > 1L, j > 1L))
expect_equal(or3s(tfd > 9L, w > 9L, d > 9L),
bor3(tfd > 9L, w > 9L, d > 9L))
expect_equal(or3s(tfe > 0L, , ),
bor3(tfe > 0L, , ))
expect_equal(or3s(tff > 1L, , ),
bor3(tff > 1L, , ))
expect_equal(or3s(tfg > 9L, , ),
bor3(tfg > 9L, , ))
expect_equal(or3s(tfh > 0L, , p >= 0L),
bor3(tfh > 0L, , p >= 0L))
expect_equal(or3s(tfi > 1L, , r >= 1L),
bor3(tfi > 1L, , r >= 1L))
expect_equal(or3s(tfj > 9L, , b >= 9L),
bor3(tfj > 9L, , b >= 9L))
expect_equal(or3s(tfk > 0L, y > 0L, ),
bor3(tfk > 0L, y > 0L, ))
expect_equal(or3s(tfl > 1L, h > 1L, ),
bor3(tfl > 1L, h > 1L, ))
expect_equal(or3s(tfm > 9L, z > 9L, ),
bor3(tfm > 9L, z > 9L, ))
expect_equal(or3s(tfn > 0L, c > 0L, y >= 0L),
bor3(tfn > 0L, c > 0L, y >= 0L))
expect_equal(or3s(tfo > 1L, k > 1L, u >= 1L),
bor3(tfo > 1L, k > 1L, u >= 1L))
expect_equal(or3s(tfp > 9L, o > 9L, c >= 9L),
bor3(tfp > 9L, o > 9L, c >= 9L))
expect_equal(or3s(tfq > 0L, , ),
bor3(tfq > 0L, , ))
expect_equal(or3s(tfr > 1L, , ),
bor3(tfr > 1L, , ))
expect_equal(or3s(tfs > 9L, , ),
bor3(tfs > 9L, , ))
expect_equal(or3s(tft > 0L, , logi_n),
bor3(tft > 0L, , logi_n))
expect_equal(or3s(tfu > 1L, , logi_c),
bor3(tfu > 1L, , logi_c))
expect_equal(or3s(tfv > 9L, , logi_t),
bor3(tfv > 9L, , logi_t))
expect_equal(or3s(tfw > 0L, j >= 0L, ),
bor3(tfw > 0L, j >= 0L, ))
expect_equal(or3s(tfx > 1L, p >= 1L, ),
bor3(tfx > 1L, p >= 1L, ))
expect_equal(or3s(tfy > 9L, y >= 9L, ),
bor3(tfy > 9L, y >= 9L, ))
expect_equal(or3s(tfz > 0L, o >= 0L, logi_j),
bor3(tfz > 0L, o >= 0L, logi_j))
expect_equal(or3s(tga > 1L, e >= 1L, logi_i),
bor3(tga > 1L, e >= 1L, logi_i))
expect_equal(or3s(tgb > 9L, d >= 9L, logi_u),
bor3(tgb > 9L, d >= 9L, logi_u))
expect_equal(or3s(tgc > 0L, , ),
bor3(tgc > 0L, , ))
expect_equal(or3s(tgd > 1L, , ),
bor3(tgd > 1L, , ))
expect_equal(or3s(tge > 9L, , ),
bor3(tge > 9L, , ))
expect_equal(or3s(tgf > 0L, , !logi_k),
bor3(tgf > 0L, , !logi_k))
expect_equal(or3s(tgg > 1L, , !logi_t),
bor3(tgg > 1L, , !logi_t))
expect_equal(or3s(tgh > 9L, , !logi_w),
bor3(tgh > 9L, , !logi_w))
expect_equal(or3s(tgi > 0L, w >= 0L, ),
bor3(tgi > 0L, w >= 0L, ))
expect_equal(or3s(tgj > 1L, f >= 1L, ),
bor3(tgj > 1L, f >= 1L, ))
expect_equal(or3s(tgk > 9L, n >= 9L, ),
bor3(tgk > 9L, n >= 9L, ))
expect_equal(or3s(tgl > 0L, a >= 0L, !logi_t),
bor3(tgl > 0L, a >= 0L, !logi_t))
expect_equal(or3s(tgm > 1L, s >= 1L, !logi_o),
bor3(tgm > 1L, s >= 1L, !logi_o))
expect_equal(or3s(tgn > 9L, k >= 9L, !logi_e),
bor3(tgn > 9L, k >= 9L, !logi_e))
expect_equal(or3s(tgo > 0L, , ),
bor3(tgo > 0L, , ))
expect_equal(or3s(tgp > 1L, , ),
bor3(tgp > 1L, , ))
expect_equal(or3s(tgq > 9L, , ),
bor3(tgq > 9L, , ))
expect_equal(or3s(tgr > 0L, , u != 0L),
bor3(tgr > 0L, , u != 0L))
expect_equal(or3s(tgs > 1L, , d != 1L),
bor3(tgs > 1L, , d != 1L))
expect_equal(or3s(tgt > 9L, , k != 9L),
bor3(tgt > 9L, , k != 9L))
expect_equal(or3s(tgu > 0L, a >= 0L, ),
bor3(tgu > 0L, a >= 0L, ))
expect_equal(or3s(tgv > 1L, j >= 1L, ),
bor3(tgv > 1L, j >= 1L, ))
expect_equal(or3s(tgw > 9L, t >= 9L, ),
bor3(tgw > 9L, t >= 9L, ))
expect_equal(or3s(tgx > 0L, i >= 0L, p != 0L),
bor3(tgx > 0L, i >= 0L, p != 0L))
expect_equal(or3s(tgy > 1L, h >= 1L, l != 1L),
bor3(tgy > 1L, h >= 1L, l != 1L))
expect_equal(or3s(tgz > 9L, u >= 9L, n != 9L),
bor3(tgz > 9L, u >= 9L, n != 9L))
expect_equal(or3s(tha > 0L, , ),
bor3(tha > 0L, , ))
expect_equal(or3s(thb > 1L, , ),
bor3(thb > 1L, , ))
expect_equal(or3s(thc > 9L, , ),
bor3(thc > 9L, , ))
expect_equal(or3s(thd > 0L, , s %between% c(-1L, 1L)),
bor3(thd > 0L, , s %between% c(-1L, 1L)))
expect_equal(or3s(the > 1L, , u %between% c(-1L, 1L)),
bor3(the > 1L, , u %between% c(-1L, 1L)))
expect_equal(or3s(thf > 9L, , h %between% c(-1L, 1L)),
bor3(thf > 9L, , h %between% c(-1L, 1L)))
expect_equal(or3s(thg > 0L, h >= 0L, ),
bor3(thg > 0L, h >= 0L, ))
expect_equal(or3s(thh > 1L, j >= 1L, ),
bor3(thh > 1L, j >= 1L, ))
expect_equal(or3s(thi > 9L, e >= 9L, ),
bor3(thi > 9L, e >= 9L, ))
expect_equal(or3s(thj > 0L, b >= 0L, o %between% c(-1L, 1L)),
bor3(thj > 0L, b >= 0L, o %between% c(-1L, 1L)))
expect_equal(or3s(thk > 1L, k >= 1L, t %between% c(-1L, 1L)),
bor3(thk > 1L, k >= 1L, t %between% c(-1L, 1L)))
expect_equal(or3s(thl > 9L, p >= 9L, h %between% c(-1L, 1L)),
bor3(thl > 9L, p >= 9L, h %between% c(-1L, 1L)))
expect_equal(or3s(thm > 0L, , ),
bor3(thm > 0L, , ))
expect_equal(or3s(thn > 1L, , ),
bor3(thn > 1L, , ))
expect_equal(or3s(tho > 9L, , ),
bor3(tho > 9L, , ))
expect_equal(or3s(thp > 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(thp > 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(thq > 1L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(thq > 1L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(thr > 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(thr > 9L, , b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ths > 0L, y >= 0L, ),
bor3(ths > 0L, y >= 0L, ))
expect_equal(or3s(tht > 1L, m >= 1L, ),
bor3(tht > 1L, m >= 1L, ))
expect_equal(or3s(thu > 9L, s >= 9L, ),
bor3(thu > 9L, s >= 9L, ))
expect_equal(or3s(thv > 0L, z >= 0L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(thv > 0L, z >= 0L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(thw > 1L, o >= 1L, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(thw > 1L, o >= 1L, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(thx > 9L, g >= 9L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(thx > 9L, g >= 9L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(thy > 0L, , ),
bor3(thy > 0L, , ))
expect_equal(or3s(thz > 1L, , ),
bor3(thz > 1L, , ))
expect_equal(or3s(tia > 9L, , ),
bor3(tia > 9L, , ))
expect_equal(or3s(tib > 0L, , s %in% 1:4),
bor3(tib > 0L, , s %in% 1:4))
expect_equal(or3s(tic > 1L, , l %in% 1:4),
bor3(tic > 1L, , l %in% 1:4))
expect_equal(or3s(tid > 9L, , y %in% 1:4),
bor3(tid > 9L, , y %in% 1:4))
expect_equal(or3s(tie > 0L, d >= 0L, ),
bor3(tie > 0L, d >= 0L, ))
expect_equal(or3s(tif > 1L, n >= 1L, ),
bor3(tif > 1L, n >= 1L, ))
expect_equal(or3s(tig > 9L, s >= 9L, ),
bor3(tig > 9L, s >= 9L, ))
expect_equal(or3s(tih > 0L, g >= 0L, f %in% 1:4),
bor3(tih > 0L, g >= 0L, f %in% 1:4))
expect_equal(or3s(tii > 1L, n >= 1L, m %in% 1:4),
bor3(tii > 1L, n >= 1L, m %in% 1:4))
expect_equal(or3s(tij > 9L, a >= 9L, d %in% 1:4),
bor3(tij > 9L, a >= 9L, d %in% 1:4))
expect_equal(or3s(tik > 0L, , ),
bor3(tik > 0L, , ))
expect_equal(or3s(til > 1L, , ),
bor3(til > 1L, , ))
expect_equal(or3s(tim > 9L, , ),
bor3(tim > 9L, , ))
expect_equal(or3s(tin > 0L, , c < 0L),
bor3(tin > 0L, , c < 0L))
expect_equal(or3s(tio > 1L, , a < 1L),
bor3(tio > 1L, , a < 1L))
expect_equal(or3s(tip > 9L, , f < 9L),
bor3(tip > 9L, , f < 9L))
expect_equal(or3s(tiq > 0L, p >= 0L, ),
bor3(tiq > 0L, p >= 0L, ))
expect_equal(or3s(tir > 1L, s >= 1L, ),
bor3(tir > 1L, s >= 1L, ))
expect_equal(or3s(tis > 9L, o >= 9L, ),
bor3(tis > 9L, o >= 9L, ))
expect_equal(or3s(tit > 0L, l >= 0L, h < 0L),
bor3(tit > 0L, l >= 0L, h < 0L))
expect_equal(or3s(tiu > 1L, l >= 1L, x < 1L),
bor3(tiu > 1L, l >= 1L, x < 1L))
expect_equal(or3s(tiv > 9L, q >= 9L, i < 9L),
bor3(tiv > 9L, q >= 9L, i < 9L))
expect_equal(or3s(tiw > 0L, , ),
bor3(tiw > 0L, , ))
expect_equal(or3s(tix > 1L, , ),
bor3(tix > 1L, , ))
expect_equal(or3s(tiy > 9L, , ),
bor3(tiy > 9L, , ))
expect_equal(or3s(tiz > 0L, , a <= 0L),
bor3(tiz > 0L, , a <= 0L))
expect_equal(or3s(tja > 1L, , k <= 1L),
bor3(tja > 1L, , k <= 1L))
expect_equal(or3s(tjb > 9L, , z <= 9L),
bor3(tjb > 9L, , z <= 9L))
expect_equal(or3s(tjc > 0L, c >= 0L, ),
bor3(tjc > 0L, c >= 0L, ))
expect_equal(or3s(tjd > 1L, t >= 1L, ),
bor3(tjd > 1L, t >= 1L, ))
expect_equal(or3s(tje > 9L, v >= 9L, ),
bor3(tje > 9L, v >= 9L, ))
expect_equal(or3s(tjf > 0L, k >= 0L, d <= 0L),
bor3(tjf > 0L, k >= 0L, d <= 0L))
expect_equal(or3s(tjg > 1L, l >= 1L, c <= 1L),
bor3(tjg > 1L, l >= 1L, c <= 1L))
expect_equal(or3s(tjh > 9L, t >= 9L, o <= 9L),
bor3(tjh > 9L, t >= 9L, o <= 9L))
expect_equal(or3s(tji > 0L, , ),
bor3(tji > 0L, , ))
expect_equal(or3s(tjj > 1L, , ),
bor3(tjj > 1L, , ))
expect_equal(or3s(tjk > 9L, , ),
bor3(tjk > 9L, , ))
expect_equal(or3s(tjl > 0L, , j == 0L),
bor3(tjl > 0L, , j == 0L))
expect_equal(or3s(tjm > 1L, , o == 1L),
bor3(tjm > 1L, , o == 1L))
expect_equal(or3s(tjn > 9L, , t == 9L),
bor3(tjn > 9L, , t == 9L))
expect_equal(or3s(tjo > 0L, o >= 0L, ),
bor3(tjo > 0L, o >= 0L, ))
expect_equal(or3s(tjp > 1L, w >= 1L, ),
bor3(tjp > 1L, w >= 1L, ))
expect_equal(or3s(tjq > 9L, a >= 9L, ),
bor3(tjq > 9L, a >= 9L, ))
expect_equal(or3s(tjr > 0L, a >= 0L, b == 0L),
bor3(tjr > 0L, a >= 0L, b == 0L))
expect_equal(or3s(tjs > 1L, a >= 1L, t == 1L),
bor3(tjs > 1L, a >= 1L, t == 1L))
expect_equal(or3s(tjt > 9L, s >= 9L, b == 9L),
bor3(tjt > 9L, s >= 9L, b == 9L))
expect_equal(or3s(tju > 0L, , ),
bor3(tju > 0L, , ))
expect_equal(or3s(tjv > 1L, , ),
bor3(tjv > 1L, , ))
expect_equal(or3s(tjw > 9L, , ),
bor3(tjw > 9L, , ))
expect_equal(or3s(tjx > 0L, , o > 0L),
bor3(tjx > 0L, , o > 0L))
expect_equal(or3s(tjy > 1L, , m > 1L),
bor3(tjy > 1L, , m > 1L))
expect_equal(or3s(tjz > 9L, , a > 9L),
bor3(tjz > 9L, , a > 9L))
expect_equal(or3s(tka > 0L, o >= 0L, ),
bor3(tka > 0L, o >= 0L, ))
expect_equal(or3s(tkb > 1L, c >= 1L, ),
bor3(tkb > 1L, c >= 1L, ))
expect_equal(or3s(tkc > 9L, q >= 9L, ),
bor3(tkc > 9L, q >= 9L, ))
expect_equal(or3s(tkd > 0L, e >= 0L, o > 0L),
bor3(tkd > 0L, e >= 0L, o > 0L))
expect_equal(or3s(tke > 1L, w >= 1L, m > 1L),
bor3(tke > 1L, w >= 1L, m > 1L))
expect_equal(or3s(tkf > 9L, f >= 9L, x > 9L),
bor3(tkf > 9L, f >= 9L, x > 9L))
expect_equal(or3s(tkg > 0L, , ),
bor3(tkg > 0L, , ))
expect_equal(or3s(tkh > 1L, , ),
bor3(tkh > 1L, , ))
expect_equal(or3s(tki > 9L, , ),
bor3(tki > 9L, , ))
expect_equal(or3s(tkj > 0L, , x >= 0L),
bor3(tkj > 0L, , x >= 0L))
expect_equal(or3s(tkk > 1L, , x >= 1L),
bor3(tkk > 1L, , x >= 1L))
expect_equal(or3s(tkl > 9L, , l >= 9L),
bor3(tkl > 9L, , l >= 9L))
expect_equal(or3s(tkm > 0L, g >= 0L, ),
bor3(tkm > 0L, g >= 0L, ))
expect_equal(or3s(tkn > 1L, g >= 1L, ),
bor3(tkn > 1L, g >= 1L, ))
expect_equal(or3s(tko > 9L, u >= 9L, ),
bor3(tko > 9L, u >= 9L, ))
expect_equal(or3s(tkp > 0L, q >= 0L, a >= 0L),
bor3(tkp > 0L, q >= 0L, a >= 0L))
expect_equal(or3s(tkq > 1L, x >= 1L, a >= 1L),
bor3(tkq > 1L, x >= 1L, a >= 1L))
expect_equal(or3s(tkr > 9L, c >= 9L, b >= 9L),
bor3(tkr > 9L, c >= 9L, b >= 9L))
expect_equal(or3s(tks >= 0L, , ),
bor3(tks >= 0L, , ))
expect_equal(or3s(tkt >= 1L, , ),
bor3(tkt >= 1L, , ))
expect_equal(or3s(tku >= 9L, , ),
bor3(tku >= 9L, , ))
expect_equal(or3s(tkv >= 0L, , logi_c),
bor3(tkv >= 0L, , logi_c))
expect_equal(or3s(tkw >= 1L, , logi_l),
bor3(tkw >= 1L, , logi_l))
expect_equal(or3s(tkx >= 9L, , logi_c),
bor3(tkx >= 9L, , logi_c))
expect_equal(or3s(tky >= 0L, logi_c, ),
bor3(tky >= 0L, logi_c, ))
expect_equal(or3s(tkz >= 1L, logi_v, ),
bor3(tkz >= 1L, logi_v, ))
expect_equal(or3s(tla >= 9L, logi_k, ),
bor3(tla >= 9L, logi_k, ))
expect_equal(or3s(tlb >= 0L, logi_v, logi_p),
bor3(tlb >= 0L, logi_v, logi_p))
expect_equal(or3s(tlc >= 1L, logi_i, logi_c),
bor3(tlc >= 1L, logi_i, logi_c))
expect_equal(or3s(tld >= 9L, logi_z, logi_v),
bor3(tld >= 9L, logi_z, logi_v))
expect_equal(or3s(tle >= 0L, , ),
bor3(tle >= 0L, , ))
expect_equal(or3s(tlf >= 1L, , ),
bor3(tlf >= 1L, , ))
expect_equal(or3s(tlg >= 9L, , ),
bor3(tlg >= 9L, , ))
expect_equal(or3s(tlh >= 0L, , !logi_x),
bor3(tlh >= 0L, , !logi_x))
expect_equal(or3s(tli >= 1L, , !logi_k),
bor3(tli >= 1L, , !logi_k))
expect_equal(or3s(tlj >= 9L, , !logi_v),
bor3(tlj >= 9L, , !logi_v))
expect_equal(or3s(tlk >= 0L, logi_d, ),
bor3(tlk >= 0L, logi_d, ))
expect_equal(or3s(tll >= 1L, logi_a, ),
bor3(tll >= 1L, logi_a, ))
expect_equal(or3s(tlm >= 9L, logi_z, ),
bor3(tlm >= 9L, logi_z, ))
expect_equal(or3s(tln >= 0L, logi_a, !logi_v),
bor3(tln >= 0L, logi_a, !logi_v))
expect_equal(or3s(tlo >= 1L, logi_g, !logi_v),
bor3(tlo >= 1L, logi_g, !logi_v))
expect_equal(or3s(tlp >= 9L, logi_b, !logi_s),
bor3(tlp >= 9L, logi_b, !logi_s))
expect_equal(or3s(tlq >= 0L, , ),
bor3(tlq >= 0L, , ))
expect_equal(or3s(tlr >= 1L, , ),
bor3(tlr >= 1L, , ))
expect_equal(or3s(tls >= 9L, , ),
bor3(tls >= 9L, , ))
expect_equal(or3s(tlt >= 0L, , z != 0L),
bor3(tlt >= 0L, , z != 0L))
expect_equal(or3s(tlu >= 1L, , e != 1L),
bor3(tlu >= 1L, , e != 1L))
expect_equal(or3s(tlv >= 9L, , k != 9L),
bor3(tlv >= 9L, , k != 9L))
expect_equal(or3s(tlw >= 0L, logi_l, ),
bor3(tlw >= 0L, logi_l, ))
expect_equal(or3s(tlx >= 1L, logi_e, ),
bor3(tlx >= 1L, logi_e, ))
expect_equal(or3s(tly >= 9L, logi_p, ),
bor3(tly >= 9L, logi_p, ))
expect_equal(or3s(tlz >= 0L, logi_m, m != 0L),
bor3(tlz >= 0L, logi_m, m != 0L))
expect_equal(or3s(tma >= 1L, logi_p, e != 1L),
bor3(tma >= 1L, logi_p, e != 1L))
expect_equal(or3s(tmb >= 9L, logi_d, z != 9L),
bor3(tmb >= 9L, logi_d, z != 9L))
expect_equal(or3s(tmc >= 0L, , ),
bor3(tmc >= 0L, , ))
expect_equal(or3s(tmd >= 1L, , ),
bor3(tmd >= 1L, , ))
expect_equal(or3s(tme >= 9L, , ),
bor3(tme >= 9L, , ))
expect_equal(or3s(tmf >= 0L, , m %between% c(-1L, 1L)),
bor3(tmf >= 0L, , m %between% c(-1L, 1L)))
expect_equal(or3s(tmg >= 1L, , b %between% c(-1L, 1L)),
bor3(tmg >= 1L, , b %between% c(-1L, 1L)))
expect_equal(or3s(tmh >= 9L, , r %between% c(-1L, 1L)),
bor3(tmh >= 9L, , r %between% c(-1L, 1L)))
expect_equal(or3s(tmi >= 0L, logi_e, ),
bor3(tmi >= 0L, logi_e, ))
expect_equal(or3s(tmj >= 1L, logi_h, ),
bor3(tmj >= 1L, logi_h, ))
expect_equal(or3s(tmk >= 9L, logi_s, ),
bor3(tmk >= 9L, logi_s, ))
expect_equal(or3s(tml >= 0L, logi_s, c %between% c(-1L, 1L)),
bor3(tml >= 0L, logi_s, c %between% c(-1L, 1L)))
expect_equal(or3s(tmm >= 1L, logi_x, p %between% c(-1L, 1L)),
bor3(tmm >= 1L, logi_x, p %between% c(-1L, 1L)))
expect_equal(or3s(tmn >= 9L, logi_i, k %between% c(-1L, 1L)),
bor3(tmn >= 9L, logi_i, k %between% c(-1L, 1L)))
expect_equal(or3s(tmo >= 0L, , ),
bor3(tmo >= 0L, , ))
expect_equal(or3s(tmp >= 1L, , ),
bor3(tmp >= 1L, , ))
expect_equal(or3s(tmq >= 9L, , ),
bor3(tmq >= 9L, , ))
expect_equal(or3s(tmr >= 0L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tmr >= 0L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tms >= 1L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tms >= 1L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tmt >= 9L, , m %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tmt >= 9L, , m %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tmu >= 0L, logi_x, ),
bor3(tmu >= 0L, logi_x, ))
expect_equal(or3s(tmv >= 1L, logi_u, ),
bor3(tmv >= 1L, logi_u, ))
expect_equal(or3s(tmw >= 9L, logi_i, ),
bor3(tmw >= 9L, logi_i, ))
expect_equal(or3s(tmx >= 0L, logi_q, q %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tmx >= 0L, logi_q, q %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tmy >= 1L, logi_f, l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tmy >= 1L, logi_f, l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tmz >= 9L, logi_v, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tmz >= 9L, logi_v, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tna >= 0L, , ),
bor3(tna >= 0L, , ))
expect_equal(or3s(tnb >= 1L, , ),
bor3(tnb >= 1L, , ))
expect_equal(or3s(tnc >= 9L, , ),
bor3(tnc >= 9L, , ))
expect_equal(or3s(tnd >= 0L, , r %in% 1:4),
bor3(tnd >= 0L, , r %in% 1:4))
expect_equal(or3s(tne >= 1L, , m %in% 1:4),
bor3(tne >= 1L, , m %in% 1:4))
expect_equal(or3s(tnf >= 9L, , n %in% 1:4),
bor3(tnf >= 9L, , n %in% 1:4))
expect_equal(or3s(tng >= 0L, logi_l, ),
bor3(tng >= 0L, logi_l, ))
expect_equal(or3s(tnh >= 1L, logi_i, ),
bor3(tnh >= 1L, logi_i, ))
expect_equal(or3s(tni >= 9L, logi_u, ),
bor3(tni >= 9L, logi_u, ))
expect_equal(or3s(tnj >= 0L, logi_r, w %in% 1:4),
bor3(tnj >= 0L, logi_r, w %in% 1:4))
expect_equal(or3s(tnk >= 1L, logi_c, p %in% 1:4),
bor3(tnk >= 1L, logi_c, p %in% 1:4))
expect_equal(or3s(tnl >= 9L, logi_m, d %in% 1:4),
bor3(tnl >= 9L, logi_m, d %in% 1:4))
expect_equal(or3s(tnm >= 0L, , ),
bor3(tnm >= 0L, , ))
expect_equal(or3s(tnn >= 1L, , ),
bor3(tnn >= 1L, , ))
expect_equal(or3s(tno >= 9L, , ),
bor3(tno >= 9L, , ))
expect_equal(or3s(tnp >= 0L, , a < 0L),
bor3(tnp >= 0L, , a < 0L))
expect_equal(or3s(tnq >= 1L, , z < 1L),
bor3(tnq >= 1L, , z < 1L))
expect_equal(or3s(tnr >= 9L, , s < 9L),
bor3(tnr >= 9L, , s < 9L))
expect_equal(or3s(tns >= 0L, logi_y, ),
bor3(tns >= 0L, logi_y, ))
expect_equal(or3s(tnt >= 1L, logi_z, ),
bor3(tnt >= 1L, logi_z, ))
expect_equal(or3s(tnu >= 9L, logi_a, ),
bor3(tnu >= 9L, logi_a, ))
expect_equal(or3s(tnv >= 0L, logi_l, k < 0L),
bor3(tnv >= 0L, logi_l, k < 0L))
expect_equal(or3s(tnw >= 1L, logi_o, v < 1L),
bor3(tnw >= 1L, logi_o, v < 1L))
expect_equal(or3s(tnx >= 9L, logi_u, l < 9L),
bor3(tnx >= 9L, logi_u, l < 9L))
expect_equal(or3s(tny >= 0L, , ),
bor3(tny >= 0L, , ))
expect_equal(or3s(tnz >= 1L, , ),
bor3(tnz >= 1L, , ))
expect_equal(or3s(toa >= 9L, , ),
bor3(toa >= 9L, , ))
expect_equal(or3s(tob >= 0L, , h <= 0L),
bor3(tob >= 0L, , h <= 0L))
expect_equal(or3s(toc >= 1L, , f <= 1L),
bor3(toc >= 1L, , f <= 1L))
expect_equal(or3s(tod >= 9L, , t <= 9L),
bor3(tod >= 9L, , t <= 9L))
expect_equal(or3s(toe >= 0L, logi_i, ),
bor3(toe >= 0L, logi_i, ))
expect_equal(or3s(tof >= 1L, logi_m, ),
bor3(tof >= 1L, logi_m, ))
expect_equal(or3s(tog >= 9L, logi_s, ),
bor3(tog >= 9L, logi_s, ))
expect_equal(or3s(toh >= 0L, logi_p, d <= 0L),
bor3(toh >= 0L, logi_p, d <= 0L))
expect_equal(or3s(toi >= 1L, logi_x, q <= 1L),
bor3(toi >= 1L, logi_x, q <= 1L))
expect_equal(or3s(toj >= 9L, logi_j, j <= 9L),
bor3(toj >= 9L, logi_j, j <= 9L))
expect_equal(or3s(tok >= 0L, , ),
bor3(tok >= 0L, , ))
expect_equal(or3s(tol >= 1L, , ),
bor3(tol >= 1L, , ))
expect_equal(or3s(tom >= 9L, , ),
bor3(tom >= 9L, , ))
expect_equal(or3s(ton >= 0L, , u == 0L),
bor3(ton >= 0L, , u == 0L))
expect_equal(or3s(too >= 1L, , u == 1L),
bor3(too >= 1L, , u == 1L))
expect_equal(or3s(top >= 9L, , f == 9L),
bor3(top >= 9L, , f == 9L))
expect_equal(or3s(toq >= 0L, logi_u, ),
bor3(toq >= 0L, logi_u, ))
expect_equal(or3s(tor >= 1L, logi_a, ),
bor3(tor >= 1L, logi_a, ))
expect_equal(or3s(tos >= 9L, logi_f, ),
bor3(tos >= 9L, logi_f, ))
expect_equal(or3s(tot >= 0L, logi_a, f == 0L),
bor3(tot >= 0L, logi_a, f == 0L))
expect_equal(or3s(tou >= 1L, logi_p, s == 1L),
bor3(tou >= 1L, logi_p, s == 1L))
expect_equal(or3s(tov >= 9L, logi_g, y == 9L),
bor3(tov >= 9L, logi_g, y == 9L))
expect_equal(or3s(tow >= 0L, , ),
bor3(tow >= 0L, , ))
expect_equal(or3s(tox >= 1L, , ),
bor3(tox >= 1L, , ))
expect_equal(or3s(toy >= 9L, , ),
bor3(toy >= 9L, , ))
expect_equal(or3s(toz >= 0L, , g > 0L),
bor3(toz >= 0L, , g > 0L))
expect_equal(or3s(tpa >= 1L, , e > 1L),
bor3(tpa >= 1L, , e > 1L))
expect_equal(or3s(tpb >= 9L, , x > 9L),
bor3(tpb >= 9L, , x > 9L))
expect_equal(or3s(tpc >= 0L, logi_d, ),
bor3(tpc >= 0L, logi_d, ))
expect_equal(or3s(tpd >= 1L, logi_j, ),
bor3(tpd >= 1L, logi_j, ))
expect_equal(or3s(tpe >= 9L, logi_a, ),
bor3(tpe >= 9L, logi_a, ))
expect_equal(or3s(tpf >= 0L, logi_n, f > 0L),
bor3(tpf >= 0L, logi_n, f > 0L))
expect_equal(or3s(tpg >= 1L, logi_w, b > 1L),
bor3(tpg >= 1L, logi_w, b > 1L))
expect_equal(or3s(tph >= 9L, logi_w, a > 9L),
bor3(tph >= 9L, logi_w, a > 9L))
expect_equal(or3s(tpi >= 0L, , ),
bor3(tpi >= 0L, , ))
expect_equal(or3s(tpj >= 1L, , ),
bor3(tpj >= 1L, , ))
expect_equal(or3s(tpk >= 9L, , ),
bor3(tpk >= 9L, , ))
expect_equal(or3s(tpl >= 0L, , o >= 0L),
bor3(tpl >= 0L, , o >= 0L))
expect_equal(or3s(tpm >= 1L, , p >= 1L),
bor3(tpm >= 1L, , p >= 1L))
expect_equal(or3s(tpn >= 9L, , b >= 9L),
bor3(tpn >= 9L, , b >= 9L))
expect_equal(or3s(tpo >= 0L, logi_r, ),
bor3(tpo >= 0L, logi_r, ))
expect_equal(or3s(tpp >= 1L, logi_r, ),
bor3(tpp >= 1L, logi_r, ))
expect_equal(or3s(tpq >= 9L, logi_m, ),
bor3(tpq >= 9L, logi_m, ))
expect_equal(or3s(tpr >= 0L, logi_q, u >= 0L),
bor3(tpr >= 0L, logi_q, u >= 0L))
expect_equal(or3s(tps >= 1L, logi_e, z >= 1L),
bor3(tps >= 1L, logi_e, z >= 1L))
expect_equal(or3s(tpt >= 9L, logi_v, g >= 9L),
bor3(tpt >= 9L, logi_v, g >= 9L))
expect_equal(or3s(tpu >= 0L, , ),
bor3(tpu >= 0L, , ))
expect_equal(or3s(tpv >= 1L, , ),
bor3(tpv >= 1L, , ))
expect_equal(or3s(tpw >= 9L, , ),
bor3(tpw >= 9L, , ))
expect_equal(or3s(tpx >= 0L, , logi_w),
bor3(tpx >= 0L, , logi_w))
expect_equal(or3s(tpy >= 1L, , logi_w),
bor3(tpy >= 1L, , logi_w))
expect_equal(or3s(tpz >= 9L, , logi_p),
bor3(tpz >= 9L, , logi_p))
expect_equal(or3s(tqa >= 0L, !logi_x, ),
bor3(tqa >= 0L, !logi_x, ))
expect_equal(or3s(tqb >= 1L, !logi_r, ),
bor3(tqb >= 1L, !logi_r, ))
expect_equal(or3s(tqc >= 9L, !logi_z, ),
bor3(tqc >= 9L, !logi_z, ))
expect_equal(or3s(tqd >= 0L, !logi_d, logi_a),
bor3(tqd >= 0L, !logi_d, logi_a))
expect_equal(or3s(tqe >= 1L, !logi_b, logi_z),
bor3(tqe >= 1L, !logi_b, logi_z))
expect_equal(or3s(tqf >= 9L, !logi_n, logi_n),
bor3(tqf >= 9L, !logi_n, logi_n))
expect_equal(or3s(tqg >= 0L, , ),
bor3(tqg >= 0L, , ))
expect_equal(or3s(tqh >= 1L, , ),
bor3(tqh >= 1L, , ))
expect_equal(or3s(tqi >= 9L, , ),
bor3(tqi >= 9L, , ))
expect_equal(or3s(tqj >= 0L, , !logi_s),
bor3(tqj >= 0L, , !logi_s))
expect_equal(or3s(tqk >= 1L, , !logi_q),
bor3(tqk >= 1L, , !logi_q))
expect_equal(or3s(tql >= 9L, , !logi_i),
bor3(tql >= 9L, , !logi_i))
expect_equal(or3s(tqm >= 0L, !logi_l, ),
bor3(tqm >= 0L, !logi_l, ))
expect_equal(or3s(tqn >= 1L, !logi_r, ),
bor3(tqn >= 1L, !logi_r, ))
expect_equal(or3s(tqo >= 9L, !logi_h, ),
bor3(tqo >= 9L, !logi_h, ))
expect_equal(or3s(tqp >= 0L, !logi_c, !logi_x),
bor3(tqp >= 0L, !logi_c, !logi_x))
expect_equal(or3s(tqq >= 1L, !logi_e, !logi_i),
bor3(tqq >= 1L, !logi_e, !logi_i))
expect_equal(or3s(tqr >= 9L, !logi_t, !logi_l),
bor3(tqr >= 9L, !logi_t, !logi_l))
expect_equal(or3s(tqs >= 0L, , ),
bor3(tqs >= 0L, , ))
expect_equal(or3s(tqt >= 1L, , ),
bor3(tqt >= 1L, , ))
expect_equal(or3s(tqu >= 9L, , ),
bor3(tqu >= 9L, , ))
expect_equal(or3s(tqv >= 0L, , y != 0L),
bor3(tqv >= 0L, , y != 0L))
expect_equal(or3s(tqw >= 1L, , k != 1L),
bor3(tqw >= 1L, , k != 1L))
expect_equal(or3s(tqx >= 9L, , q != 9L),
bor3(tqx >= 9L, , q != 9L))
expect_equal(or3s(tqy >= 0L, !logi_k, ),
bor3(tqy >= 0L, !logi_k, ))
expect_equal(or3s(tqz >= 1L, !logi_d, ),
bor3(tqz >= 1L, !logi_d, ))
expect_equal(or3s(tra >= 9L, !logi_j, ),
bor3(tra >= 9L, !logi_j, ))
expect_equal(or3s(trb >= 0L, !logi_r, p != 0L),
bor3(trb >= 0L, !logi_r, p != 0L))
expect_equal(or3s(trc >= 1L, !logi_h, i != 1L),
bor3(trc >= 1L, !logi_h, i != 1L))
expect_equal(or3s(trd >= 9L, !logi_h, v != 9L),
bor3(trd >= 9L, !logi_h, v != 9L))
expect_equal(or3s(tre >= 0L, , ),
bor3(tre >= 0L, , ))
expect_equal(or3s(trf >= 1L, , ),
bor3(trf >= 1L, , ))
expect_equal(or3s(trg >= 9L, , ),
bor3(trg >= 9L, , ))
expect_equal(or3s(trh >= 0L, , s %between% c(-1L, 1L)),
bor3(trh >= 0L, , s %between% c(-1L, 1L)))
expect_equal(or3s(tri >= 1L, , g %between% c(-1L, 1L)),
bor3(tri >= 1L, , g %between% c(-1L, 1L)))
expect_equal(or3s(trj >= 9L, , e %between% c(-1L, 1L)),
bor3(trj >= 9L, , e %between% c(-1L, 1L)))
expect_equal(or3s(trk >= 0L, !logi_y, ),
bor3(trk >= 0L, !logi_y, ))
expect_equal(or3s(trl >= 1L, !logi_i, ),
bor3(trl >= 1L, !logi_i, ))
expect_equal(or3s(trm >= 9L, !logi_l, ),
bor3(trm >= 9L, !logi_l, ))
expect_equal(or3s(trn >= 0L, !logi_e, m %between% c(-1L, 1L)),
bor3(trn >= 0L, !logi_e, m %between% c(-1L, 1L)))
expect_equal(or3s(tro >= 1L, !logi_i, q %between% c(-1L, 1L)),
bor3(tro >= 1L, !logi_i, q %between% c(-1L, 1L)))
expect_equal(or3s(trp >= 9L, !logi_q, j %between% c(-1L, 1L)),
bor3(trp >= 9L, !logi_q, j %between% c(-1L, 1L)))
expect_equal(or3s(trq >= 0L, , ),
bor3(trq >= 0L, , ))
expect_equal(or3s(trr >= 1L, , ),
bor3(trr >= 1L, , ))
expect_equal(or3s(trs >= 9L, , ),
bor3(trs >= 9L, , ))
expect_equal(or3s(trt >= 0L, , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(trt >= 0L, , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tru >= 1L, , i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tru >= 1L, , i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(trv >= 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(trv >= 9L, , z %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(trw >= 0L, !logi_h, ),
bor3(trw >= 0L, !logi_h, ))
expect_equal(or3s(trx >= 1L, !logi_a, ),
bor3(trx >= 1L, !logi_a, ))
expect_equal(or3s(try >= 9L, !logi_y, ),
bor3(try >= 9L, !logi_y, ))
expect_equal(or3s(trz >= 0L, !logi_n, x %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(trz >= 0L, !logi_n, x %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tsa >= 1L, !logi_o, r %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tsa >= 1L, !logi_o, r %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tsb >= 9L, !logi_h, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tsb >= 9L, !logi_h, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tsc >= 0L, , ),
bor3(tsc >= 0L, , ))
expect_equal(or3s(tsd >= 1L, , ),
bor3(tsd >= 1L, , ))
expect_equal(or3s(tse >= 9L, , ),
bor3(tse >= 9L, , ))
expect_equal(or3s(tsf >= 0L, , t %in% 1:4),
bor3(tsf >= 0L, , t %in% 1:4))
expect_equal(or3s(tsg >= 1L, , y %in% 1:4),
bor3(tsg >= 1L, , y %in% 1:4))
expect_equal(or3s(tsh >= 9L, , i %in% 1:4),
bor3(tsh >= 9L, , i %in% 1:4))
expect_equal(or3s(tsi >= 0L, !logi_a, ),
bor3(tsi >= 0L, !logi_a, ))
expect_equal(or3s(tsj >= 1L, !logi_t, ),
bor3(tsj >= 1L, !logi_t, ))
expect_equal(or3s(tsk >= 9L, !logi_f, ),
bor3(tsk >= 9L, !logi_f, ))
expect_equal(or3s(tsl >= 0L, !logi_q, k %in% 1:4),
bor3(tsl >= 0L, !logi_q, k %in% 1:4))
expect_equal(or3s(tsm >= 1L, !logi_i, b %in% 1:4),
bor3(tsm >= 1L, !logi_i, b %in% 1:4))
expect_equal(or3s(tsn >= 9L, !logi_z, k %in% 1:4),
bor3(tsn >= 9L, !logi_z, k %in% 1:4))
expect_equal(or3s(tso >= 0L, , ),
bor3(tso >= 0L, , ))
expect_equal(or3s(tsp >= 1L, , ),
bor3(tsp >= 1L, , ))
expect_equal(or3s(tsq >= 9L, , ),
bor3(tsq >= 9L, , ))
expect_equal(or3s(tsr >= 0L, , w < 0L),
bor3(tsr >= 0L, , w < 0L))
expect_equal(or3s(tss >= 1L, , s < 1L),
bor3(tss >= 1L, , s < 1L))
expect_equal(or3s(tst >= 9L, , b < 9L),
bor3(tst >= 9L, , b < 9L))
expect_equal(or3s(tsu >= 0L, !logi_l, ),
bor3(tsu >= 0L, !logi_l, ))
expect_equal(or3s(tsv >= 1L, !logi_c, ),
bor3(tsv >= 1L, !logi_c, ))
expect_equal(or3s(tsw >= 9L, !logi_e, ),
bor3(tsw >= 9L, !logi_e, ))
expect_equal(or3s(tsx >= 0L, !logi_c, t < 0L),
bor3(tsx >= 0L, !logi_c, t < 0L))
expect_equal(or3s(tsy >= 1L, !logi_y, r < 1L),
bor3(tsy >= 1L, !logi_y, r < 1L))
expect_equal(or3s(tsz >= 9L, !logi_y, y < 9L),
bor3(tsz >= 9L, !logi_y, y < 9L))
expect_equal(or3s(tta >= 0L, , ),
bor3(tta >= 0L, , ))
expect_equal(or3s(ttb >= 1L, , ),
bor3(ttb >= 1L, , ))
expect_equal(or3s(ttc >= 9L, , ),
bor3(ttc >= 9L, , ))
expect_equal(or3s(ttd >= 0L, , u <= 0L),
bor3(ttd >= 0L, , u <= 0L))
expect_equal(or3s(tte >= 1L, , l <= 1L),
bor3(tte >= 1L, , l <= 1L))
expect_equal(or3s(ttf >= 9L, , a <= 9L),
bor3(ttf >= 9L, , a <= 9L))
expect_equal(or3s(ttg >= 0L, !logi_m, ),
bor3(ttg >= 0L, !logi_m, ))
expect_equal(or3s(tth >= 1L, !logi_o, ),
bor3(tth >= 1L, !logi_o, ))
expect_equal(or3s(tti >= 9L, !logi_i, ),
bor3(tti >= 9L, !logi_i, ))
expect_equal(or3s(ttj >= 0L, !logi_r, i <= 0L),
bor3(ttj >= 0L, !logi_r, i <= 0L))
expect_equal(or3s(ttk >= 1L, !logi_r, z <= 1L),
bor3(ttk >= 1L, !logi_r, z <= 1L))
expect_equal(or3s(ttl >= 9L, !logi_e, c <= 9L),
bor3(ttl >= 9L, !logi_e, c <= 9L))
expect_equal(or3s(ttm >= 0L, , ),
bor3(ttm >= 0L, , ))
expect_equal(or3s(ttn >= 1L, , ),
bor3(ttn >= 1L, , ))
expect_equal(or3s(tto >= 9L, , ),
bor3(tto >= 9L, , ))
expect_equal(or3s(ttp >= 0L, , i == 0L),
bor3(ttp >= 0L, , i == 0L))
expect_equal(or3s(ttq >= 1L, , p == 1L),
bor3(ttq >= 1L, , p == 1L))
expect_equal(or3s(ttr >= 9L, , a == 9L),
bor3(ttr >= 9L, , a == 9L))
expect_equal(or3s(tts >= 0L, !logi_r, ),
bor3(tts >= 0L, !logi_r, ))
expect_equal(or3s(ttt >= 1L, !logi_f, ),
bor3(ttt >= 1L, !logi_f, ))
expect_equal(or3s(ttu >= 9L, !logi_x, ),
bor3(ttu >= 9L, !logi_x, ))
expect_equal(or3s(ttv >= 0L, !logi_q, y == 0L),
bor3(ttv >= 0L, !logi_q, y == 0L))
expect_equal(or3s(ttw >= 1L, !logi_w, p == 1L),
bor3(ttw >= 1L, !logi_w, p == 1L))
expect_equal(or3s(ttx >= 9L, !logi_b, c == 9L),
bor3(ttx >= 9L, !logi_b, c == 9L))
expect_equal(or3s(tty >= 0L, , ),
bor3(tty >= 0L, , ))
expect_equal(or3s(ttz >= 1L, , ),
bor3(ttz >= 1L, , ))
expect_equal(or3s(tua >= 9L, , ),
bor3(tua >= 9L, , ))
expect_equal(or3s(tub >= 0L, , m > 0L),
bor3(tub >= 0L, , m > 0L))
expect_equal(or3s(tuc >= 1L, , p > 1L),
bor3(tuc >= 1L, , p > 1L))
expect_equal(or3s(tud >= 9L, , t > 9L),
bor3(tud >= 9L, , t > 9L))
expect_equal(or3s(tue >= 0L, !logi_c, ),
bor3(tue >= 0L, !logi_c, ))
expect_equal(or3s(tuf >= 1L, !logi_t, ),
bor3(tuf >= 1L, !logi_t, ))
expect_equal(or3s(tug >= 9L, !logi_n, ),
bor3(tug >= 9L, !logi_n, ))
expect_equal(or3s(tuh >= 0L, !logi_o, i > 0L),
bor3(tuh >= 0L, !logi_o, i > 0L))
expect_equal(or3s(tui >= 1L, !logi_k, j > 1L),
bor3(tui >= 1L, !logi_k, j > 1L))
expect_equal(or3s(tuj >= 9L, !logi_r, o > 9L),
bor3(tuj >= 9L, !logi_r, o > 9L))
expect_equal(or3s(tuk >= 0L, , ),
bor3(tuk >= 0L, , ))
expect_equal(or3s(tul >= 1L, , ),
bor3(tul >= 1L, , ))
expect_equal(or3s(tum >= 9L, , ),
bor3(tum >= 9L, , ))
expect_equal(or3s(tun >= 0L, , z >= 0L),
bor3(tun >= 0L, , z >= 0L))
expect_equal(or3s(tuo >= 1L, , x >= 1L),
bor3(tuo >= 1L, , x >= 1L))
expect_equal(or3s(tup >= 9L, , s >= 9L),
bor3(tup >= 9L, , s >= 9L))
expect_equal(or3s(tuq >= 0L, !logi_x, ),
bor3(tuq >= 0L, !logi_x, ))
expect_equal(or3s(tur >= 1L, !logi_b, ),
bor3(tur >= 1L, !logi_b, ))
expect_equal(or3s(tus >= 9L, !logi_d, ),
bor3(tus >= 9L, !logi_d, ))
expect_equal(or3s(tut >= 0L, !logi_b, n >= 0L),
bor3(tut >= 0L, !logi_b, n >= 0L))
expect_equal(or3s(tuu >= 1L, !logi_j, o >= 1L),
bor3(tuu >= 1L, !logi_j, o >= 1L))
expect_equal(or3s(tuv >= 9L, !logi_y, j >= 9L),
bor3(tuv >= 9L, !logi_y, j >= 9L))
expect_equal(or3s(tuw >= 0L, , ),
bor3(tuw >= 0L, , ))
expect_equal(or3s(tux >= 1L, , ),
bor3(tux >= 1L, , ))
expect_equal(or3s(tuy >= 9L, , ),
bor3(tuy >= 9L, , ))
expect_equal(or3s(tuz >= 0L, , logi_j),
bor3(tuz >= 0L, , logi_j))
expect_equal(or3s(tva >= 1L, , logi_y),
bor3(tva >= 1L, , logi_y))
expect_equal(or3s(tvb >= 9L, , logi_m),
bor3(tvb >= 9L, , logi_m))
expect_equal(or3s(tvc >= 0L, k != 0L, ),
bor3(tvc >= 0L, k != 0L, ))
expect_equal(or3s(tvd >= 1L, b != 1L, ),
bor3(tvd >= 1L, b != 1L, ))
expect_equal(or3s(tve >= 9L, c != 9L, ),
bor3(tve >= 9L, c != 9L, ))
expect_equal(or3s(tvf >= 0L, y != 0L, logi_j),
bor3(tvf >= 0L, y != 0L, logi_j))
expect_equal(or3s(tvg >= 1L, u != 1L, logi_x),
bor3(tvg >= 1L, u != 1L, logi_x))
expect_equal(or3s(tvh >= 9L, p != 9L, logi_u),
bor3(tvh >= 9L, p != 9L, logi_u))
expect_equal(or3s(tvi >= 0L, , ),
bor3(tvi >= 0L, , ))
expect_equal(or3s(tvj >= 1L, , ),
bor3(tvj >= 1L, , ))
expect_equal(or3s(tvk >= 9L, , ),
bor3(tvk >= 9L, , ))
expect_equal(or3s(tvl >= 0L, , !logi_h),
bor3(tvl >= 0L, , !logi_h))
expect_equal(or3s(tvm >= 1L, , !logi_u),
bor3(tvm >= 1L, , !logi_u))
expect_equal(or3s(tvn >= 9L, , !logi_y),
bor3(tvn >= 9L, , !logi_y))
expect_equal(or3s(tvo >= 0L, e != 0L, ),
bor3(tvo >= 0L, e != 0L, ))
expect_equal(or3s(tvp >= 1L, f != 1L, ),
bor3(tvp >= 1L, f != 1L, ))
expect_equal(or3s(tvq >= 9L, a != 9L, ),
bor3(tvq >= 9L, a != 9L, ))
expect_equal(or3s(tvr >= 0L, e != 0L, !logi_v),
bor3(tvr >= 0L, e != 0L, !logi_v))
expect_equal(or3s(tvs >= 1L, j != 1L, !logi_n),
bor3(tvs >= 1L, j != 1L, !logi_n))
expect_equal(or3s(tvt >= 9L, a != 9L, !logi_n),
bor3(tvt >= 9L, a != 9L, !logi_n))
expect_equal(or3s(tvu >= 0L, , ),
bor3(tvu >= 0L, , ))
expect_equal(or3s(tvv >= 1L, , ),
bor3(tvv >= 1L, , ))
expect_equal(or3s(tvw >= 9L, , ),
bor3(tvw >= 9L, , ))
expect_equal(or3s(tvx >= 0L, , g != 0L),
bor3(tvx >= 0L, , g != 0L))
expect_equal(or3s(tvy >= 1L, , j != 1L),
bor3(tvy >= 1L, , j != 1L))
expect_equal(or3s(tvz >= 9L, , y != 9L),
bor3(tvz >= 9L, , y != 9L))
expect_equal(or3s(twa >= 0L, p != 0L, ),
bor3(twa >= 0L, p != 0L, ))
expect_equal(or3s(twb >= 1L, i != 1L, ),
bor3(twb >= 1L, i != 1L, ))
expect_equal(or3s(twc >= 9L, j != 9L, ),
bor3(twc >= 9L, j != 9L, ))
expect_equal(or3s(twd >= 0L, h != 0L, h != 0L),
bor3(twd >= 0L, h != 0L, h != 0L))
expect_equal(or3s(twe >= 1L, x != 1L, x != 1L),
bor3(twe >= 1L, x != 1L, x != 1L))
expect_equal(or3s(twf >= 9L, o != 9L, a != 9L),
bor3(twf >= 9L, o != 9L, a != 9L))
expect_equal(or3s(twg >= 0L, , ),
bor3(twg >= 0L, , ))
expect_equal(or3s(twh >= 1L, , ),
bor3(twh >= 1L, , ))
expect_equal(or3s(twi >= 9L, , ),
bor3(twi >= 9L, , ))
expect_equal(or3s(twj >= 0L, , o %between% c(-1L, 1L)),
bor3(twj >= 0L, , o %between% c(-1L, 1L)))
expect_equal(or3s(twk >= 1L, , t %between% c(-1L, 1L)),
bor3(twk >= 1L, , t %between% c(-1L, 1L)))
expect_equal(or3s(twl >= 9L, , o %between% c(-1L, 1L)),
bor3(twl >= 9L, , o %between% c(-1L, 1L)))
expect_equal(or3s(twm >= 0L, q != 0L, ),
bor3(twm >= 0L, q != 0L, ))
expect_equal(or3s(twn >= 1L, q != 1L, ),
bor3(twn >= 1L, q != 1L, ))
expect_equal(or3s(two >= 9L, y != 9L, ),
bor3(two >= 9L, y != 9L, ))
expect_equal(or3s(twp >= 0L, y != 0L, h %between% c(-1L, 1L)),
bor3(twp >= 0L, y != 0L, h %between% c(-1L, 1L)))
expect_equal(or3s(twq >= 1L, g != 1L, m %between% c(-1L, 1L)),
bor3(twq >= 1L, g != 1L, m %between% c(-1L, 1L)))
expect_equal(or3s(twr >= 9L, o != 9L, t %between% c(-1L, 1L)),
bor3(twr >= 9L, o != 9L, t %between% c(-1L, 1L)))
expect_equal(or3s(tws >= 0L, , ),
bor3(tws >= 0L, , ))
expect_equal(or3s(twt >= 1L, , ),
bor3(twt >= 1L, , ))
expect_equal(or3s(twu >= 9L, , ),
bor3(twu >= 9L, , ))
expect_equal(or3s(twv >= 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(twv >= 0L, , p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(tww >= 1L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(tww >= 1L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(twx >= 9L, , y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(twx >= 9L, , y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(twy >= 0L, r != 0L, ),
bor3(twy >= 0L, r != 0L, ))
expect_equal(or3s(twz >= 1L, p != 1L, ),
bor3(twz >= 1L, p != 1L, ))
expect_equal(or3s(txa >= 9L, m != 9L, ),
bor3(txa >= 9L, m != 9L, ))
expect_equal(or3s(txb >= 0L, h != 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(txb >= 0L, h != 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(txc >= 1L, j != 1L, b %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(txc >= 1L, j != 1L, b %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(txd >= 9L, e != 9L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(txd >= 9L, e != 9L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(txe >= 0L, , ),
bor3(txe >= 0L, , ))
expect_equal(or3s(txf >= 1L, , ),
bor3(txf >= 1L, , ))
expect_equal(or3s(txg >= 9L, , ),
bor3(txg >= 9L, , ))
expect_equal(or3s(txh >= 0L, , m %in% 1:4),
bor3(txh >= 0L, , m %in% 1:4))
expect_equal(or3s(txi >= 1L, , v %in% 1:4),
bor3(txi >= 1L, , v %in% 1:4))
expect_equal(or3s(txj >= 9L, , e %in% 1:4),
bor3(txj >= 9L, , e %in% 1:4))
expect_equal(or3s(txk >= 0L, g != 0L, ),
bor3(txk >= 0L, g != 0L, ))
expect_equal(or3s(txl >= 1L, w != 1L, ),
bor3(txl >= 1L, w != 1L, ))
expect_equal(or3s(txm >= 9L, d != 9L, ),
bor3(txm >= 9L, d != 9L, ))
expect_equal(or3s(txn >= 0L, z != 0L, x %in% 1:4),
bor3(txn >= 0L, z != 0L, x %in% 1:4))
expect_equal(or3s(txo >= 1L, o != 1L, i %in% 1:4),
bor3(txo >= 1L, o != 1L, i %in% 1:4))
expect_equal(or3s(txp >= 9L, b != 9L, e %in% 1:4),
bor3(txp >= 9L, b != 9L, e %in% 1:4))
expect_equal(or3s(txq >= 0L, , ),
bor3(txq >= 0L, , ))
expect_equal(or3s(txr >= 1L, , ),
bor3(txr >= 1L, , ))
expect_equal(or3s(txs >= 9L, , ),
bor3(txs >= 9L, , ))
expect_equal(or3s(txt >= 0L, , a < 0L),
bor3(txt >= 0L, , a < 0L))
expect_equal(or3s(txu >= 1L, , q < 1L),
bor3(txu >= 1L, , q < 1L))
expect_equal(or3s(txv >= 9L, , x < 9L),
bor3(txv >= 9L, , x < 9L))
expect_equal(or3s(txw >= 0L, w != 0L, ),
bor3(txw >= 0L, w != 0L, ))
expect_equal(or3s(txx >= 1L, d != 1L, ),
bor3(txx >= 1L, d != 1L, ))
expect_equal(or3s(txy >= 9L, q != 9L, ),
bor3(txy >= 9L, q != 9L, ))
expect_equal(or3s(txz >= 0L, i != 0L, t < 0L),
bor3(txz >= 0L, i != 0L, t < 0L))
expect_equal(or3s(tya >= 1L, m != 1L, h < 1L),
bor3(tya >= 1L, m != 1L, h < 1L))
expect_equal(or3s(tyb >= 9L, g != 9L, k < 9L),
bor3(tyb >= 9L, g != 9L, k < 9L))
expect_equal(or3s(tyc >= 0L, , ),
bor3(tyc >= 0L, , ))
expect_equal(or3s(tyd >= 1L, , ),
bor3(tyd >= 1L, , ))
expect_equal(or3s(tye >= 9L, , ),
bor3(tye >= 9L, , ))
expect_equal(or3s(tyf >= 0L, , o <= 0L),
bor3(tyf >= 0L, , o <= 0L))
expect_equal(or3s(tyg >= 1L, , k <= 1L),
bor3(tyg >= 1L, , k <= 1L))
expect_equal(or3s(tyh >= 9L, , q <= 9L),
bor3(tyh >= 9L, , q <= 9L))
expect_equal(or3s(tyi >= 0L, y != 0L, ),
bor3(tyi >= 0L, y != 0L, ))
expect_equal(or3s(tyj >= 1L, t != 1L, ),
bor3(tyj >= 1L, t != 1L, ))
expect_equal(or3s(tyk >= 9L, s != 9L, ),
bor3(tyk >= 9L, s != 9L, ))
expect_equal(or3s(tyl >= 0L, j != 0L, d <= 0L),
bor3(tyl >= 0L, j != 0L, d <= 0L))
expect_equal(or3s(tym >= 1L, o != 1L, m <= 1L),
bor3(tym >= 1L, o != 1L, m <= 1L))
expect_equal(or3s(tyn >= 9L, k != 9L, h <= 9L),
bor3(tyn >= 9L, k != 9L, h <= 9L))
expect_equal(or3s(tyo >= 0L, , ),
bor3(tyo >= 0L, , ))
expect_equal(or3s(typ >= 1L, , ),
bor3(typ >= 1L, , ))
expect_equal(or3s(tyq >= 9L, , ),
bor3(tyq >= 9L, , ))
expect_equal(or3s(tyr >= 0L, , s == 0L),
bor3(tyr >= 0L, , s == 0L))
expect_equal(or3s(tys >= 1L, , p == 1L),
bor3(tys >= 1L, , p == 1L))
expect_equal(or3s(tyt >= 9L, , k == 9L),
bor3(tyt >= 9L, , k == 9L))
expect_equal(or3s(tyu >= 0L, y != 0L, ),
bor3(tyu >= 0L, y != 0L, ))
expect_equal(or3s(tyv >= 1L, l != 1L, ),
bor3(tyv >= 1L, l != 1L, ))
expect_equal(or3s(tyw >= 9L, z != 9L, ),
bor3(tyw >= 9L, z != 9L, ))
expect_equal(or3s(tyx >= 0L, l != 0L, v == 0L),
bor3(tyx >= 0L, l != 0L, v == 0L))
expect_equal(or3s(tyy >= 1L, t != 1L, f == 1L),
bor3(tyy >= 1L, t != 1L, f == 1L))
expect_equal(or3s(tyz >= 9L, y != 9L, n == 9L),
bor3(tyz >= 9L, y != 9L, n == 9L))
expect_equal(or3s(ua >= 0L, , ),
bor3(ua >= 0L, , ))
expect_equal(or3s(ub >= 1L, , ),
bor3(ub >= 1L, , ))
expect_equal(or3s(uc >= 9L, , ),
bor3(uc >= 9L, , ))
expect_equal(or3s(ud >= 0L, , t > 0L),
bor3(ud >= 0L, , t > 0L))
expect_equal(or3s(ue >= 1L, , z > 1L),
bor3(ue >= 1L, , z > 1L))
expect_equal(or3s(uf >= 9L, , y > 9L),
bor3(uf >= 9L, , y > 9L))
expect_equal(or3s(ug >= 0L, v != 0L, ),
bor3(ug >= 0L, v != 0L, ))
expect_equal(or3s(uh >= 1L, g != 1L, ),
bor3(uh >= 1L, g != 1L, ))
expect_equal(or3s(ui >= 9L, x != 9L, ),
bor3(ui >= 9L, x != 9L, ))
expect_equal(or3s(uj >= 0L, o != 0L, o > 0L),
bor3(uj >= 0L, o != 0L, o > 0L))
expect_equal(or3s(uk >= 1L, f != 1L, n > 1L),
bor3(uk >= 1L, f != 1L, n > 1L))
expect_equal(or3s(ul >= 9L, h != 9L, x > 9L),
bor3(ul >= 9L, h != 9L, x > 9L))
expect_equal(or3s(um >= 0L, , ),
bor3(um >= 0L, , ))
expect_equal(or3s(un >= 1L, , ),
bor3(un >= 1L, , ))
expect_equal(or3s(uo >= 9L, , ),
bor3(uo >= 9L, , ))
expect_equal(or3s(up >= 0L, , z >= 0L),
bor3(up >= 0L, , z >= 0L))
expect_equal(or3s(uq >= 1L, , d >= 1L),
bor3(uq >= 1L, , d >= 1L))
expect_equal(or3s(ur >= 9L, , v >= 9L),
bor3(ur >= 9L, , v >= 9L))
expect_equal(or3s(us >= 0L, z != 0L, ),
bor3(us >= 0L, z != 0L, ))
expect_equal(or3s(ut >= 1L, s != 1L, ),
bor3(ut >= 1L, s != 1L, ))
expect_equal(or3s(uu >= 9L, l != 9L, ),
bor3(uu >= 9L, l != 9L, ))
expect_equal(or3s(uv >= 0L, x != 0L, j >= 0L),
bor3(uv >= 0L, x != 0L, j >= 0L))
expect_equal(or3s(uw >= 1L, v != 1L, e >= 1L),
bor3(uw >= 1L, v != 1L, e >= 1L))
expect_equal(or3s(ux >= 9L, j != 9L, i >= 9L),
bor3(ux >= 9L, j != 9L, i >= 9L))
expect_equal(or3s(uy >= 0L, , ),
bor3(uy >= 0L, , ))
expect_equal(or3s(uz >= 1L, , ),
bor3(uz >= 1L, , ))
expect_equal(or3s(uaa >= 9L, , ),
bor3(uaa >= 9L, , ))
expect_equal(or3s(uab >= 0L, , logi_f),
bor3(uab >= 0L, , logi_f))
expect_equal(or3s(uac >= 1L, , logi_a),
bor3(uac >= 1L, , logi_a))
expect_equal(or3s(uad >= 9L, , logi_k),
bor3(uad >= 9L, , logi_k))
expect_equal(or3s(uae >= 0L, a %between% c(-1L, 1L), ),
bor3(uae >= 0L, a %between% c(-1L, 1L), ))
expect_equal(or3s(uaf >= 1L, i %between% c(-1L, 1L), ),
bor3(uaf >= 1L, i %between% c(-1L, 1L), ))
expect_equal(or3s(uag >= 9L, f %between% c(-1L, 1L), ),
bor3(uag >= 9L, f %between% c(-1L, 1L), ))
expect_equal(or3s(uah >= 0L, m %between% c(-1L, 1L), logi_e),
bor3(uah >= 0L, m %between% c(-1L, 1L), logi_e))
expect_equal(or3s(uai >= 1L, h %between% c(-1L, 1L), logi_q),
bor3(uai >= 1L, h %between% c(-1L, 1L), logi_q))
expect_equal(or3s(uaj >= 9L, z %between% c(-1L, 1L), logi_d),
bor3(uaj >= 9L, z %between% c(-1L, 1L), logi_d))
expect_equal(or3s(uak >= 0L, , ),
bor3(uak >= 0L, , ))
expect_equal(or3s(ual >= 1L, , ),
bor3(ual >= 1L, , ))
expect_equal(or3s(uam >= 9L, , ),
bor3(uam >= 9L, , ))
expect_equal(or3s(uan >= 0L, , !logi_p),
bor3(uan >= 0L, , !logi_p))
expect_equal(or3s(uao >= 1L, , !logi_i),
bor3(uao >= 1L, , !logi_i))
expect_equal(or3s(uap >= 9L, , !logi_e),
bor3(uap >= 9L, , !logi_e))
expect_equal(or3s(uaq >= 0L, p %between% c(-1L, 1L), ),
bor3(uaq >= 0L, p %between% c(-1L, 1L), ))
expect_equal(or3s(uar >= 1L, x %between% c(-1L, 1L), ),
bor3(uar >= 1L, x %between% c(-1L, 1L), ))
expect_equal(or3s(uas >= 9L, v %between% c(-1L, 1L), ),
bor3(uas >= 9L, v %between% c(-1L, 1L), ))
expect_equal(or3s(uat >= 0L, d %between% c(-1L, 1L), !logi_y),
bor3(uat >= 0L, d %between% c(-1L, 1L), !logi_y))
expect_equal(or3s(uau >= 1L, j %between% c(-1L, 1L), !logi_t),
bor3(uau >= 1L, j %between% c(-1L, 1L), !logi_t))
expect_equal(or3s(uav >= 9L, j %between% c(-1L, 1L), !logi_y),
bor3(uav >= 9L, j %between% c(-1L, 1L), !logi_y))
expect_equal(or3s(uaw >= 0L, , ),
bor3(uaw >= 0L, , ))
expect_equal(or3s(uax >= 1L, , ),
bor3(uax >= 1L, , ))
expect_equal(or3s(uay >= 9L, , ),
bor3(uay >= 9L, , ))
expect_equal(or3s(uaz >= 0L, , j != 0L),
bor3(uaz >= 0L, , j != 0L))
expect_equal(or3s(uba >= 1L, , s != 1L),
bor3(uba >= 1L, , s != 1L))
expect_equal(or3s(ubb >= 9L, , e != 9L),
bor3(ubb >= 9L, , e != 9L))
expect_equal(or3s(ubc >= 0L, j %between% c(-1L, 1L), ),
bor3(ubc >= 0L, j %between% c(-1L, 1L), ))
expect_equal(or3s(ubd >= 1L, f %between% c(-1L, 1L), ),
bor3(ubd >= 1L, f %between% c(-1L, 1L), ))
expect_equal(or3s(ube >= 9L, j %between% c(-1L, 1L), ),
bor3(ube >= 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(ubf >= 0L, w %between% c(-1L, 1L), h != 0L),
bor3(ubf >= 0L, w %between% c(-1L, 1L), h != 0L))
expect_equal(or3s(ubg >= 1L, k %between% c(-1L, 1L), h != 1L),
bor3(ubg >= 1L, k %between% c(-1L, 1L), h != 1L))
expect_equal(or3s(ubh >= 9L, j %between% c(-1L, 1L), u != 9L),
bor3(ubh >= 9L, j %between% c(-1L, 1L), u != 9L))
expect_equal(or3s(ubi >= 0L, , ),
bor3(ubi >= 0L, , ))
expect_equal(or3s(ubj >= 1L, , ),
bor3(ubj >= 1L, , ))
expect_equal(or3s(ubk >= 9L, , ),
bor3(ubk >= 9L, , ))
expect_equal(or3s(ubl >= 0L, , q %between% c(-1L, 1L)),
bor3(ubl >= 0L, , q %between% c(-1L, 1L)))
expect_equal(or3s(ubm >= 1L, , h %between% c(-1L, 1L)),
bor3(ubm >= 1L, , h %between% c(-1L, 1L)))
expect_equal(or3s(ubn >= 9L, , x %between% c(-1L, 1L)),
bor3(ubn >= 9L, , x %between% c(-1L, 1L)))
expect_equal(or3s(ubo >= 0L, q %between% c(-1L, 1L), ),
bor3(ubo >= 0L, q %between% c(-1L, 1L), ))
expect_equal(or3s(ubp >= 1L, n %between% c(-1L, 1L), ),
bor3(ubp >= 1L, n %between% c(-1L, 1L), ))
expect_equal(or3s(ubq >= 9L, v %between% c(-1L, 1L), ),
bor3(ubq >= 9L, v %between% c(-1L, 1L), ))
expect_equal(or3s(ubr >= 0L, y %between% c(-1L, 1L), m %between% c(-1L, 1L)),
bor3(ubr >= 0L, y %between% c(-1L, 1L), m %between% c(-1L, 1L)))
expect_equal(or3s(ubs >= 1L, o %between% c(-1L, 1L), j %between% c(-1L, 1L)),
bor3(ubs >= 1L, o %between% c(-1L, 1L), j %between% c(-1L, 1L)))
expect_equal(or3s(ubt >= 9L, a %between% c(-1L, 1L), k %between% c(-1L, 1L)),
bor3(ubt >= 9L, a %between% c(-1L, 1L), k %between% c(-1L, 1L)))
expect_equal(or3s(ubu >= 0L, , ),
bor3(ubu >= 0L, , ))
expect_equal(or3s(ubv >= 1L, , ),
bor3(ubv >= 1L, , ))
expect_equal(or3s(ubw >= 9L, , ),
bor3(ubw >= 9L, , ))
expect_equal(or3s(ubx >= 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ubx >= 0L, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uby >= 1L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uby >= 1L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ubz >= 9L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ubz >= 9L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uca >= 0L, q %between% c(-1L, 1L), ),
bor3(uca >= 0L, q %between% c(-1L, 1L), ))
expect_equal(or3s(ucb >= 1L, c %between% c(-1L, 1L), ),
bor3(ucb >= 1L, c %between% c(-1L, 1L), ))
expect_equal(or3s(ucc >= 9L, j %between% c(-1L, 1L), ),
bor3(ucc >= 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(ucd >= 0L, s %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ucd >= 0L, s %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uce >= 1L, t %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uce >= 1L, t %between% c(-1L, 1L), p %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ucf >= 9L, h %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ucf >= 9L, h %between% c(-1L, 1L), a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ucg >= 0L, , ),
bor3(ucg >= 0L, , ))
expect_equal(or3s(uch >= 1L, , ),
bor3(uch >= 1L, , ))
expect_equal(or3s(uci >= 9L, , ),
bor3(uci >= 9L, , ))
expect_equal(or3s(ucj >= 0L, , i %in% 1:4),
bor3(ucj >= 0L, , i %in% 1:4))
expect_equal(or3s(uck >= 1L, , g %in% 1:4),
bor3(uck >= 1L, , g %in% 1:4))
expect_equal(or3s(ucl >= 9L, , w %in% 1:4),
bor3(ucl >= 9L, , w %in% 1:4))
expect_equal(or3s(ucm >= 0L, e %between% c(-1L, 1L), ),
bor3(ucm >= 0L, e %between% c(-1L, 1L), ))
expect_equal(or3s(ucn >= 1L, a %between% c(-1L, 1L), ),
bor3(ucn >= 1L, a %between% c(-1L, 1L), ))
expect_equal(or3s(uco >= 9L, j %between% c(-1L, 1L), ),
bor3(uco >= 9L, j %between% c(-1L, 1L), ))
expect_equal(or3s(ucp >= 0L, r %between% c(-1L, 1L), q %in% 1:4),
bor3(ucp >= 0L, r %between% c(-1L, 1L), q %in% 1:4))
expect_equal(or3s(ucq >= 1L, a %between% c(-1L, 1L), t %in% 1:4),
bor3(ucq >= 1L, a %between% c(-1L, 1L), t %in% 1:4))
expect_equal(or3s(ucr >= 9L, t %between% c(-1L, 1L), e %in% 1:4),
bor3(ucr >= 9L, t %between% c(-1L, 1L), e %in% 1:4))
expect_equal(or3s(ucs >= 0L, , ),
bor3(ucs >= 0L, , ))
expect_equal(or3s(uct >= 1L, , ),
bor3(uct >= 1L, , ))
expect_equal(or3s(ucu >= 9L, , ),
bor3(ucu >= 9L, , ))
expect_equal(or3s(ucv >= 0L, , q < 0L),
bor3(ucv >= 0L, , q < 0L))
expect_equal(or3s(ucw >= 1L, , n < 1L),
bor3(ucw >= 1L, , n < 1L))
expect_equal(or3s(ucx >= 9L, , u < 9L),
bor3(ucx >= 9L, , u < 9L))
expect_equal(or3s(ucy >= 0L, i %between% c(-1L, 1L), ),
bor3(ucy >= 0L, i %between% c(-1L, 1L), ))
expect_equal(or3s(ucz >= 1L, s %between% c(-1L, 1L), ),
bor3(ucz >= 1L, s %between% c(-1L, 1L), ))
expect_equal(or3s(uda >= 9L, e %between% c(-1L, 1L), ),
bor3(uda >= 9L, e %between% c(-1L, 1L), ))
expect_equal(or3s(udb >= 0L, q %between% c(-1L, 1L), u < 0L),
bor3(udb >= 0L, q %between% c(-1L, 1L), u < 0L))
expect_equal(or3s(udc >= 1L, b %between% c(-1L, 1L), u < 1L),
bor3(udc >= 1L, b %between% c(-1L, 1L), u < 1L))
expect_equal(or3s(udd >= 9L, h %between% c(-1L, 1L), b < 9L),
bor3(udd >= 9L, h %between% c(-1L, 1L), b < 9L))
expect_equal(or3s(ude >= 0L, , ),
bor3(ude >= 0L, , ))
expect_equal(or3s(udf >= 1L, , ),
bor3(udf >= 1L, , ))
expect_equal(or3s(udg >= 9L, , ),
bor3(udg >= 9L, , ))
expect_equal(or3s(udh >= 0L, , n <= 0L),
bor3(udh >= 0L, , n <= 0L))
expect_equal(or3s(udi >= 1L, , v <= 1L),
bor3(udi >= 1L, , v <= 1L))
expect_equal(or3s(udj >= 9L, , a <= 9L),
bor3(udj >= 9L, , a <= 9L))
expect_equal(or3s(udk >= 0L, i %between% c(-1L, 1L), ),
bor3(udk >= 0L, i %between% c(-1L, 1L), ))
expect_equal(or3s(udl >= 1L, m %between% c(-1L, 1L), ),
bor3(udl >= 1L, m %between% c(-1L, 1L), ))
expect_equal(or3s(udm >= 9L, i %between% c(-1L, 1L), ),
bor3(udm >= 9L, i %between% c(-1L, 1L), ))
expect_equal(or3s(udn >= 0L, s %between% c(-1L, 1L), i <= 0L),
bor3(udn >= 0L, s %between% c(-1L, 1L), i <= 0L))
expect_equal(or3s(udo >= 1L, v %between% c(-1L, 1L), e <= 1L),
bor3(udo >= 1L, v %between% c(-1L, 1L), e <= 1L))
expect_equal(or3s(udp >= 9L, w %between% c(-1L, 1L), w <= 9L),
bor3(udp >= 9L, w %between% c(-1L, 1L), w <= 9L))
expect_equal(or3s(udq >= 0L, , ),
bor3(udq >= 0L, , ))
expect_equal(or3s(udr >= 1L, , ),
bor3(udr >= 1L, , ))
expect_equal(or3s(uds >= 9L, , ),
bor3(uds >= 9L, , ))
expect_equal(or3s(udt >= 0L, , a == 0L),
bor3(udt >= 0L, , a == 0L))
expect_equal(or3s(udu >= 1L, , d == 1L),
bor3(udu >= 1L, , d == 1L))
expect_equal(or3s(udv >= 9L, , n == 9L),
bor3(udv >= 9L, , n == 9L))
expect_equal(or3s(udw >= 0L, w %between% c(-1L, 1L), ),
bor3(udw >= 0L, w %between% c(-1L, 1L), ))
expect_equal(or3s(udx >= 1L, x %between% c(-1L, 1L), ),
bor3(udx >= 1L, x %between% c(-1L, 1L), ))
expect_equal(or3s(udy >= 9L, a %between% c(-1L, 1L), ),
bor3(udy >= 9L, a %between% c(-1L, 1L), ))
expect_equal(or3s(udz >= 0L, w %between% c(-1L, 1L), i == 0L),
bor3(udz >= 0L, w %between% c(-1L, 1L), i == 0L))
expect_equal(or3s(uea >= 1L, z %between% c(-1L, 1L), m == 1L),
bor3(uea >= 1L, z %between% c(-1L, 1L), m == 1L))
expect_equal(or3s(ueb >= 9L, q %between% c(-1L, 1L), a == 9L),
bor3(ueb >= 9L, q %between% c(-1L, 1L), a == 9L))
expect_equal(or3s(uec >= 0L, , ),
bor3(uec >= 0L, , ))
expect_equal(or3s(ued >= 1L, , ),
bor3(ued >= 1L, , ))
expect_equal(or3s(uee >= 9L, , ),
bor3(uee >= 9L, , ))
expect_equal(or3s(uef >= 0L, , a > 0L),
bor3(uef >= 0L, , a > 0L))
expect_equal(or3s(ueg >= 1L, , p > 1L),
bor3(ueg >= 1L, , p > 1L))
expect_equal(or3s(ueh >= 9L, , z > 9L),
bor3(ueh >= 9L, , z > 9L))
expect_equal(or3s(uei >= 0L, b %between% c(-1L, 1L), ),
bor3(uei >= 0L, b %between% c(-1L, 1L), ))
expect_equal(or3s(uej >= 1L, g %between% c(-1L, 1L), ),
bor3(uej >= 1L, g %between% c(-1L, 1L), ))
expect_equal(or3s(uek >= 9L, l %between% c(-1L, 1L), ),
bor3(uek >= 9L, l %between% c(-1L, 1L), ))
expect_equal(or3s(uel >= 0L, l %between% c(-1L, 1L), w > 0L),
bor3(uel >= 0L, l %between% c(-1L, 1L), w > 0L))
expect_equal(or3s(uem >= 1L, u %between% c(-1L, 1L), p > 1L),
bor3(uem >= 1L, u %between% c(-1L, 1L), p > 1L))
expect_equal(or3s(uen >= 9L, c %between% c(-1L, 1L), m > 9L),
bor3(uen >= 9L, c %between% c(-1L, 1L), m > 9L))
expect_equal(or3s(ueo >= 0L, , ),
bor3(ueo >= 0L, , ))
expect_equal(or3s(uep >= 1L, , ),
bor3(uep >= 1L, , ))
expect_equal(or3s(ueq >= 9L, , ),
bor3(ueq >= 9L, , ))
expect_equal(or3s(uer >= 0L, , k >= 0L),
bor3(uer >= 0L, , k >= 0L))
expect_equal(or3s(ues >= 1L, , g >= 1L),
bor3(ues >= 1L, , g >= 1L))
expect_equal(or3s(uet >= 9L, , f >= 9L),
bor3(uet >= 9L, , f >= 9L))
expect_equal(or3s(ueu >= 0L, s %between% c(-1L, 1L), ),
bor3(ueu >= 0L, s %between% c(-1L, 1L), ))
expect_equal(or3s(uev >= 1L, h %between% c(-1L, 1L), ),
bor3(uev >= 1L, h %between% c(-1L, 1L), ))
expect_equal(or3s(uew >= 9L, n %between% c(-1L, 1L), ),
bor3(uew >= 9L, n %between% c(-1L, 1L), ))
expect_equal(or3s(uex >= 0L, y %between% c(-1L, 1L), v >= 0L),
bor3(uex >= 0L, y %between% c(-1L, 1L), v >= 0L))
expect_equal(or3s(uey >= 1L, o %between% c(-1L, 1L), f >= 1L),
bor3(uey >= 1L, o %between% c(-1L, 1L), f >= 1L))
expect_equal(or3s(uez >= 9L, t %between% c(-1L, 1L), d >= 9L),
bor3(uez >= 9L, t %between% c(-1L, 1L), d >= 9L))
expect_equal(or3s(ufa >= 0L, , ),
bor3(ufa >= 0L, , ))
expect_equal(or3s(ufb >= 1L, , ),
bor3(ufb >= 1L, , ))
expect_equal(or3s(ufc >= 9L, , ),
bor3(ufc >= 9L, , ))
expect_equal(or3s(ufd >= 0L, , logi_t),
bor3(ufd >= 0L, , logi_t))
expect_equal(or3s(ufe >= 1L, , logi_c),
bor3(ufe >= 1L, , logi_c))
expect_equal(or3s(uff >= 9L, , logi_a),
bor3(uff >= 9L, , logi_a))
expect_equal(or3s(ufg >= 0L, k %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ufg >= 0L, k %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ufh >= 1L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ufh >= 1L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ufi >= 9L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ufi >= 9L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ufj >= 0L, m %in% c(4L, -3L, 2L, 7L, 8L), logi_y),
bor3(ufj >= 0L, m %in% c(4L, -3L, 2L, 7L, 8L), logi_y))
expect_equal(or3s(ufk >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), logi_k),
bor3(ufk >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), logi_k))
expect_equal(or3s(ufl >= 9L, m %in% c(4L, -3L, 2L, 7L, 8L), logi_g),
bor3(ufl >= 9L, m %in% c(4L, -3L, 2L, 7L, 8L), logi_g))
expect_equal(or3s(ufm >= 0L, , ),
bor3(ufm >= 0L, , ))
expect_equal(or3s(ufn >= 1L, , ),
bor3(ufn >= 1L, , ))
expect_equal(or3s(ufo >= 9L, , ),
bor3(ufo >= 9L, , ))
expect_equal(or3s(ufp >= 0L, , logi_v),
bor3(ufp >= 0L, , logi_v))
expect_equal(or3s(ufq >= 1L, , logi_l),
bor3(ufq >= 1L, , logi_l))
expect_equal(or3s(ufr >= 9L, , logi_h),
bor3(ufr >= 9L, , logi_h))
expect_equal(or3s(ufs >= 0L, k %in% 1:4, ),
bor3(ufs >= 0L, k %in% 1:4, ))
expect_equal(or3s(uft >= 1L, o %in% 1:4, ),
bor3(uft >= 1L, o %in% 1:4, ))
expect_equal(or3s(ufu >= 9L, h %in% 1:4, ),
bor3(ufu >= 9L, h %in% 1:4, ))
expect_equal(or3s(ufv >= 0L, a %in% 1:4, logi_q),
bor3(ufv >= 0L, a %in% 1:4, logi_q))
expect_equal(or3s(ufw >= 1L, c %in% 1:4, logi_w),
bor3(ufw >= 1L, c %in% 1:4, logi_w))
expect_equal(or3s(ufx >= 9L, p %in% 1:4, logi_y),
bor3(ufx >= 9L, p %in% 1:4, logi_y))
expect_equal(or3s(ufy >= 0L, , ),
bor3(ufy >= 0L, , ))
expect_equal(or3s(ufz >= 1L, , ),
bor3(ufz >= 1L, , ))
expect_equal(or3s(uga >= 9L, , ),
bor3(uga >= 9L, , ))
expect_equal(or3s(ugb >= 0L, , !logi_z),
bor3(ugb >= 0L, , !logi_z))
expect_equal(or3s(ugc >= 1L, , !logi_n),
bor3(ugc >= 1L, , !logi_n))
expect_equal(or3s(ugd >= 9L, , !logi_w),
bor3(ugd >= 9L, , !logi_w))
expect_equal(or3s(uge >= 0L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uge >= 0L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ugf >= 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ugf >= 1L, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ugg >= 9L, w %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ugg >= 9L, w %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ugh >= 0L, v %in% c(4L, -3L, 2L, 7L, 8L), !logi_z),
bor3(ugh >= 0L, v %in% c(4L, -3L, 2L, 7L, 8L), !logi_z))
expect_equal(or3s(ugi >= 1L, q %in% c(4L, -3L, 2L, 7L, 8L), !logi_g),
bor3(ugi >= 1L, q %in% c(4L, -3L, 2L, 7L, 8L), !logi_g))
expect_equal(or3s(ugj >= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), !logi_l),
bor3(ugj >= 9L, e %in% c(4L, -3L, 2L, 7L, 8L), !logi_l))
expect_equal(or3s(ugk >= 0L, , ),
bor3(ugk >= 0L, , ))
expect_equal(or3s(ugl >= 1L, , ),
bor3(ugl >= 1L, , ))
expect_equal(or3s(ugm >= 9L, , ),
bor3(ugm >= 9L, , ))
expect_equal(or3s(ugn >= 0L, , !logi_k),
bor3(ugn >= 0L, , !logi_k))
expect_equal(or3s(ugo >= 1L, , !logi_e),
bor3(ugo >= 1L, , !logi_e))
expect_equal(or3s(ugp >= 9L, , !logi_n),
bor3(ugp >= 9L, , !logi_n))
expect_equal(or3s(ugq >= 0L, z %in% 1:4, ),
bor3(ugq >= 0L, z %in% 1:4, ))
expect_equal(or3s(ugr >= 1L, o %in% 1:4, ),
bor3(ugr >= 1L, o %in% 1:4, ))
expect_equal(or3s(ugs >= 9L, t %in% 1:4, ),
bor3(ugs >= 9L, t %in% 1:4, ))
expect_equal(or3s(ugt >= 0L, g %in% 1:4, !logi_j),
bor3(ugt >= 0L, g %in% 1:4, !logi_j))
expect_equal(or3s(ugu >= 1L, d %in% 1:4, !logi_t),
bor3(ugu >= 1L, d %in% 1:4, !logi_t))
expect_equal(or3s(ugv >= 9L, h %in% 1:4, !logi_v),
bor3(ugv >= 9L, h %in% 1:4, !logi_v))
expect_equal(or3s(ugw >= 0L, , ),
bor3(ugw >= 0L, , ))
expect_equal(or3s(ugx >= 1L, , ),
bor3(ugx >= 1L, , ))
expect_equal(or3s(ugy >= 9L, , ),
bor3(ugy >= 9L, , ))
expect_equal(or3s(ugz >= 0L, , h != 0L),
bor3(ugz >= 0L, , h != 0L))
expect_equal(or3s(uha >= 1L, , m != 1L),
bor3(uha >= 1L, , m != 1L))
expect_equal(or3s(uhb >= 9L, , r != 9L),
bor3(uhb >= 9L, , r != 9L))
expect_equal(or3s(uhc >= 0L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uhc >= 0L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uhd >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uhd >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uhe >= 9L, v %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uhe >= 9L, v %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uhf >= 0L, y %in% c(4L, -3L, 2L, 7L, 8L), z != 0L),
bor3(uhf >= 0L, y %in% c(4L, -3L, 2L, 7L, 8L), z != 0L))
expect_equal(or3s(uhg >= 1L, d %in% c(4L, -3L, 2L, 7L, 8L), c != 1L),
bor3(uhg >= 1L, d %in% c(4L, -3L, 2L, 7L, 8L), c != 1L))
expect_equal(or3s(uhh >= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), w != 9L),
bor3(uhh >= 9L, o %in% c(4L, -3L, 2L, 7L, 8L), w != 9L))
expect_equal(or3s(uhi >= 0L, , ),
bor3(uhi >= 0L, , ))
expect_equal(or3s(uhj >= 1L, , ),
bor3(uhj >= 1L, , ))
expect_equal(or3s(uhk >= 9L, , ),
bor3(uhk >= 9L, , ))
expect_equal(or3s(uhl >= 0L, , y != 0L),
bor3(uhl >= 0L, , y != 0L))
expect_equal(or3s(uhm >= 1L, , s != 1L),
bor3(uhm >= 1L, , s != 1L))
expect_equal(or3s(uhn >= 9L, , r != 9L),
bor3(uhn >= 9L, , r != 9L))
expect_equal(or3s(uho >= 0L, v %in% 1:4, ),
bor3(uho >= 0L, v %in% 1:4, ))
expect_equal(or3s(uhp >= 1L, w %in% 1:4, ),
bor3(uhp >= 1L, w %in% 1:4, ))
expect_equal(or3s(uhq >= 9L, l %in% 1:4, ),
bor3(uhq >= 9L, l %in% 1:4, ))
expect_equal(or3s(uhr >= 0L, x %in% 1:4, l != 0L),
bor3(uhr >= 0L, x %in% 1:4, l != 0L))
expect_equal(or3s(uhs >= 1L, h %in% 1:4, m != 1L),
bor3(uhs >= 1L, h %in% 1:4, m != 1L))
expect_equal(or3s(uht >= 9L, w %in% 1:4, t != 9L),
bor3(uht >= 9L, w %in% 1:4, t != 9L))
expect_equal(or3s(uhu >= 0L, , ),
bor3(uhu >= 0L, , ))
expect_equal(or3s(uhv >= 1L, , ),
bor3(uhv >= 1L, , ))
expect_equal(or3s(uhw >= 9L, , ),
bor3(uhw >= 9L, , ))
expect_equal(or3s(uhx >= 0L, , x %between% c(-1L, 1L)),
bor3(uhx >= 0L, , x %between% c(-1L, 1L)))
expect_equal(or3s(uhy >= 1L, , r %between% c(-1L, 1L)),
bor3(uhy >= 1L, , r %between% c(-1L, 1L)))
expect_equal(or3s(uhz >= 9L, , y %between% c(-1L, 1L)),
bor3(uhz >= 9L, , y %between% c(-1L, 1L)))
expect_equal(or3s(uia >= 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uia >= 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uib >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uib >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uic >= 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uic >= 9L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uid >= 0L, q %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)),
bor3(uid >= 0L, q %in% c(4L, -3L, 2L, 7L, 8L), n %between% c(-1L, 1L)))
expect_equal(or3s(uie >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), i %between% c(-1L, 1L)),
bor3(uie >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), i %between% c(-1L, 1L)))
expect_equal(or3s(uif >= 9L, w %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)),
bor3(uif >= 9L, w %in% c(4L, -3L, 2L, 7L, 8L), y %between% c(-1L, 1L)))
expect_equal(or3s(uig >= 0L, , ),
bor3(uig >= 0L, , ))
expect_equal(or3s(uih >= 1L, , ),
bor3(uih >= 1L, , ))
expect_equal(or3s(uii >= 9L, , ),
bor3(uii >= 9L, , ))
expect_equal(or3s(uij >= 0L, , l %between% c(-1L, 1L)),
bor3(uij >= 0L, , l %between% c(-1L, 1L)))
expect_equal(or3s(uik >= 1L, , l %between% c(-1L, 1L)),
bor3(uik >= 1L, , l %between% c(-1L, 1L)))
expect_equal(or3s(uil >= 9L, , j %between% c(-1L, 1L)),
bor3(uil >= 9L, , j %between% c(-1L, 1L)))
expect_equal(or3s(uim >= 0L, a %in% 1:4, ),
bor3(uim >= 0L, a %in% 1:4, ))
expect_equal(or3s(uin >= 1L, o %in% 1:4, ),
bor3(uin >= 1L, o %in% 1:4, ))
expect_equal(or3s(uio >= 9L, v %in% 1:4, ),
bor3(uio >= 9L, v %in% 1:4, ))
expect_equal(or3s(uip >= 0L, p %in% 1:4, w %between% c(-1L, 1L)),
bor3(uip >= 0L, p %in% 1:4, w %between% c(-1L, 1L)))
expect_equal(or3s(uiq >= 1L, u %in% 1:4, m %between% c(-1L, 1L)),
bor3(uiq >= 1L, u %in% 1:4, m %between% c(-1L, 1L)))
expect_equal(or3s(uir >= 9L, v %in% 1:4, g %between% c(-1L, 1L)),
bor3(uir >= 9L, v %in% 1:4, g %between% c(-1L, 1L)))
expect_equal(or3s(uis >= 0L, , ),
bor3(uis >= 0L, , ))
expect_equal(or3s(uit >= 1L, , ),
bor3(uit >= 1L, , ))
expect_equal(or3s(uiu >= 9L, , ),
bor3(uiu >= 9L, , ))
expect_equal(or3s(uiv >= 0L, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uiv >= 0L, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uiw >= 1L, , j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uiw >= 1L, , j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uix >= 9L, , h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uix >= 9L, , h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uiy >= 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uiy >= 0L, i %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uiz >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uiz >= 1L, o %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(uja >= 9L, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uja >= 9L, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ujb >= 0L, b %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ujb >= 0L, b %in% c(4L, -3L, 2L, 7L, 8L), c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ujc >= 1L, n %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ujc >= 1L, n %in% c(4L, -3L, 2L, 7L, 8L), v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(ujd >= 9L, p %in% c(4L, -3L, 2L, 7L, 8L), y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(ujd >= 9L, p %in% c(4L, -3L, 2L, 7L, 8L), y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uje >= 0L, , ),
bor3(uje >= 0L, , ))
expect_equal(or3s(ujf >= 1L, , ),
bor3(ujf >= 1L, , ))
expect_equal(or3s(ujg >= 9L, , ),
bor3(ujg >= 9L, , ))
expect_equal(or3s(ujh >= 0L, , a %in% 1:4),
bor3(ujh >= 0L, , a %in% 1:4))
expect_equal(or3s(uji >= 1L, , m %in% 1:4),
bor3(uji >= 1L, , m %in% 1:4))
expect_equal(or3s(ujj >= 9L, , h %in% 1:4),
bor3(ujj >= 9L, , h %in% 1:4))
expect_equal(or3s(ujk >= 0L, d %in% 1:4, ),
bor3(ujk >= 0L, d %in% 1:4, ))
expect_equal(or3s(ujl >= 1L, a %in% 1:4, ),
bor3(ujl >= 1L, a %in% 1:4, ))
expect_equal(or3s(ujm >= 9L, y %in% 1:4, ),
bor3(ujm >= 9L, y %in% 1:4, ))
expect_equal(or3s(ujn >= 0L, y %in% 1:4, l %in% 1:4),
bor3(ujn >= 0L, y %in% 1:4, l %in% 1:4))
expect_equal(or3s(ujo >= 1L, e %in% 1:4, b %in% 1:4),
bor3(ujo >= 1L, e %in% 1:4, b %in% 1:4))
expect_equal(or3s(ujp >= 9L, r %in% 1:4, e %in% 1:4),
bor3(ujp >= 9L, r %in% 1:4, e %in% 1:4))
expect_equal(or3s(ujq >= 0L, , ),
bor3(ujq >= 0L, , ))
expect_equal(or3s(ujr >= 1L, , ),
bor3(ujr >= 1L, , ))
expect_equal(or3s(ujs >= 9L, , ),
bor3(ujs >= 9L, , ))
expect_equal(or3s(ujt >= 0L, , o < 0L),
bor3(ujt >= 0L, , o < 0L))
expect_equal(or3s(uju >= 1L, , w < 1L),
bor3(uju >= 1L, , w < 1L))
expect_equal(or3s(ujv >= 9L, , l < 9L),
bor3(ujv >= 9L, , l < 9L))
expect_equal(or3s(ujw >= 0L, m %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ujw >= 0L, m %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ujx >= 1L, e %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ujx >= 1L, e %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ujy >= 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ujy >= 9L, g %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ujz >= 0L, y %in% c(4L, -3L, 2L, 7L, 8L), d < 0L),
bor3(ujz >= 0L, y %in% c(4L, -3L, 2L, 7L, 8L), d < 0L))
expect_equal(or3s(uka >= 1L, u %in% c(4L, -3L, 2L, 7L, 8L), e < 1L),
bor3(uka >= 1L, u %in% c(4L, -3L, 2L, 7L, 8L), e < 1L))
expect_equal(or3s(ukb >= 9L, y %in% c(4L, -3L, 2L, 7L, 8L), c < 9L),
bor3(ukb >= 9L, y %in% c(4L, -3L, 2L, 7L, 8L), c < 9L))
expect_equal(or3s(ukc >= 0L, , ),
bor3(ukc >= 0L, , ))
expect_equal(or3s(ukd >= 1L, , ),
bor3(ukd >= 1L, , ))
expect_equal(or3s(uke >= 9L, , ),
bor3(uke >= 9L, , ))
expect_equal(or3s(ukf >= 0L, , z < 0L),
bor3(ukf >= 0L, , z < 0L))
expect_equal(or3s(ukg >= 1L, , t < 1L),
bor3(ukg >= 1L, , t < 1L))
expect_equal(or3s(ukh >= 9L, , w < 9L),
bor3(ukh >= 9L, , w < 9L))
expect_equal(or3s(uki >= 0L, s %in% 1:4, ),
bor3(uki >= 0L, s %in% 1:4, ))
expect_equal(or3s(ukj >= 1L, z %in% 1:4, ),
bor3(ukj >= 1L, z %in% 1:4, ))
expect_equal(or3s(ukk >= 9L, d %in% 1:4, ),
bor3(ukk >= 9L, d %in% 1:4, ))
expect_equal(or3s(ukl >= 0L, m %in% 1:4, p < 0L),
bor3(ukl >= 0L, m %in% 1:4, p < 0L))
expect_equal(or3s(ukm >= 1L, g %in% 1:4, v < 1L),
bor3(ukm >= 1L, g %in% 1:4, v < 1L))
expect_equal(or3s(ukn >= 9L, j %in% 1:4, r < 9L),
bor3(ukn >= 9L, j %in% 1:4, r < 9L))
expect_equal(or3s(uko >= 0L, , ),
bor3(uko >= 0L, , ))
expect_equal(or3s(ukp >= 1L, , ),
bor3(ukp >= 1L, , ))
expect_equal(or3s(ukq >= 9L, , ),
bor3(ukq >= 9L, , ))
expect_equal(or3s(ukr >= 0L, , c <= 0L),
bor3(ukr >= 0L, , c <= 0L))
expect_equal(or3s(uks >= 1L, , k <= 1L),
bor3(uks >= 1L, , k <= 1L))
expect_equal(or3s(ukt >= 9L, , h <= 9L),
bor3(ukt >= 9L, , h <= 9L))
expect_equal(or3s(uku >= 0L, b %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uku >= 0L, b %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ukv >= 1L, f %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ukv >= 1L, f %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ukw >= 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ukw >= 9L, q %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ukx >= 0L, z %in% c(4L, -3L, 2L, 7L, 8L), t <= 0L),
bor3(ukx >= 0L, z %in% c(4L, -3L, 2L, 7L, 8L), t <= 0L))
expect_equal(or3s(uky >= 1L, d %in% c(4L, -3L, 2L, 7L, 8L), a <= 1L),
bor3(uky >= 1L, d %in% c(4L, -3L, 2L, 7L, 8L), a <= 1L))
expect_equal(or3s(ukz >= 9L, k %in% c(4L, -3L, 2L, 7L, 8L), j <= 9L),
bor3(ukz >= 9L, k %in% c(4L, -3L, 2L, 7L, 8L), j <= 9L))
expect_equal(or3s(ula >= 0L, , ),
bor3(ula >= 0L, , ))
expect_equal(or3s(ulb >= 1L, , ),
bor3(ulb >= 1L, , ))
expect_equal(or3s(ulc >= 9L, , ),
bor3(ulc >= 9L, , ))
expect_equal(or3s(uld >= 0L, , p <= 0L),
bor3(uld >= 0L, , p <= 0L))
expect_equal(or3s(ule >= 1L, , v <= 1L),
bor3(ule >= 1L, , v <= 1L))
expect_equal(or3s(ulf >= 9L, , j <= 9L),
bor3(ulf >= 9L, , j <= 9L))
expect_equal(or3s(ulg >= 0L, p %in% 1:4, ),
bor3(ulg >= 0L, p %in% 1:4, ))
expect_equal(or3s(ulh >= 1L, v %in% 1:4, ),
bor3(ulh >= 1L, v %in% 1:4, ))
expect_equal(or3s(uli >= 9L, g %in% 1:4, ),
bor3(uli >= 9L, g %in% 1:4, ))
expect_equal(or3s(ulj >= 0L, s %in% 1:4, b <= 0L),
bor3(ulj >= 0L, s %in% 1:4, b <= 0L))
expect_equal(or3s(ulk >= 1L, s %in% 1:4, o <= 1L),
bor3(ulk >= 1L, s %in% 1:4, o <= 1L))
expect_equal(or3s(ull >= 9L, m %in% 1:4, k <= 9L),
bor3(ull >= 9L, m %in% 1:4, k <= 9L))
expect_equal(or3s(ulm >= 0L, , ),
bor3(ulm >= 0L, , ))
expect_equal(or3s(uln >= 1L, , ),
bor3(uln >= 1L, , ))
expect_equal(or3s(ulo >= 9L, , ),
bor3(ulo >= 9L, , ))
expect_equal(or3s(ulp >= 0L, , x == 0L),
bor3(ulp >= 0L, , x == 0L))
expect_equal(or3s(ulq >= 1L, , n == 1L),
bor3(ulq >= 1L, , n == 1L))
expect_equal(or3s(ulr >= 9L, , x == 9L),
bor3(ulr >= 9L, , x == 9L))
expect_equal(or3s(uls >= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uls >= 0L, c %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ult >= 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ult >= 1L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ulu >= 9L, x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ulu >= 9L, x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ulv >= 0L, l %in% c(4L, -3L, 2L, 7L, 8L), f == 0L),
bor3(ulv >= 0L, l %in% c(4L, -3L, 2L, 7L, 8L), f == 0L))
expect_equal(or3s(ulw >= 1L, l %in% c(4L, -3L, 2L, 7L, 8L), k == 1L),
bor3(ulw >= 1L, l %in% c(4L, -3L, 2L, 7L, 8L), k == 1L))
expect_equal(or3s(ulx >= 9L, j %in% c(4L, -3L, 2L, 7L, 8L), z == 9L),
bor3(ulx >= 9L, j %in% c(4L, -3L, 2L, 7L, 8L), z == 9L))
expect_equal(or3s(uly >= 0L, , ),
bor3(uly >= 0L, , ))
expect_equal(or3s(ulz >= 1L, , ),
bor3(ulz >= 1L, , ))
expect_equal(or3s(uma >= 9L, , ),
bor3(uma >= 9L, , ))
expect_equal(or3s(umb >= 0L, , c == 0L),
bor3(umb >= 0L, , c == 0L))
expect_equal(or3s(umc >= 1L, , y == 1L),
bor3(umc >= 1L, , y == 1L))
expect_equal(or3s(umd >= 9L, , a == 9L),
bor3(umd >= 9L, , a == 9L))
expect_equal(or3s(ume >= 0L, y %in% 1:4, ),
bor3(ume >= 0L, y %in% 1:4, ))
expect_equal(or3s(umf >= 1L, j %in% 1:4, ),
bor3(umf >= 1L, j %in% 1:4, ))
expect_equal(or3s(umg >= 9L, u %in% 1:4, ),
bor3(umg >= 9L, u %in% 1:4, ))
expect_equal(or3s(umh >= 0L, b %in% 1:4, x == 0L),
bor3(umh >= 0L, b %in% 1:4, x == 0L))
expect_equal(or3s(umi >= 1L, e %in% 1:4, u == 1L),
bor3(umi >= 1L, e %in% 1:4, u == 1L))
expect_equal(or3s(umj >= 9L, p %in% 1:4, j == 9L),
bor3(umj >= 9L, p %in% 1:4, j == 9L))
expect_equal(or3s(umk >= 0L, , ),
bor3(umk >= 0L, , ))
expect_equal(or3s(uml >= 1L, , ),
bor3(uml >= 1L, , ))
expect_equal(or3s(umm >= 9L, , ),
bor3(umm >= 9L, , ))
expect_equal(or3s(umn >= 0L, , x > 0L),
bor3(umn >= 0L, , x > 0L))
expect_equal(or3s(umo >= 1L, , a > 1L),
bor3(umo >= 1L, , a > 1L))
expect_equal(or3s(ump >= 9L, , u > 9L),
bor3(ump >= 9L, , u > 9L))
expect_equal(or3s(umq >= 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(umq >= 0L, s %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(umr >= 1L, z %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(umr >= 1L, z %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(ums >= 9L, d %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(ums >= 9L, d %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(umt >= 0L, e %in% c(4L, -3L, 2L, 7L, 8L), m > 0L),
bor3(umt >= 0L, e %in% c(4L, -3L, 2L, 7L, 8L), m > 0L))
expect_equal(or3s(umu >= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), f > 1L),
bor3(umu >= 1L, t %in% c(4L, -3L, 2L, 7L, 8L), f > 1L))
expect_equal(or3s(umv >= 9L, l %in% c(4L, -3L, 2L, 7L, 8L), r > 9L),
bor3(umv >= 9L, l %in% c(4L, -3L, 2L, 7L, 8L), r > 9L))
expect_equal(or3s(umw >= 0L, , ),
bor3(umw >= 0L, , ))
expect_equal(or3s(umx >= 1L, , ),
bor3(umx >= 1L, , ))
expect_equal(or3s(umy >= 9L, , ),
bor3(umy >= 9L, , ))
expect_equal(or3s(umz >= 0L, , u > 0L),
bor3(umz >= 0L, , u > 0L))
expect_equal(or3s(una >= 1L, , j > 1L),
bor3(una >= 1L, , j > 1L))
expect_equal(or3s(unb >= 9L, , s > 9L),
bor3(unb >= 9L, , s > 9L))
expect_equal(or3s(unc >= 0L, o %in% 1:4, ),
bor3(unc >= 0L, o %in% 1:4, ))
expect_equal(or3s(und >= 1L, e %in% 1:4, ),
bor3(und >= 1L, e %in% 1:4, ))
expect_equal(or3s(une >= 9L, b %in% 1:4, ),
bor3(une >= 9L, b %in% 1:4, ))
expect_equal(or3s(unf >= 0L, f %in% 1:4, n > 0L),
bor3(unf >= 0L, f %in% 1:4, n > 0L))
expect_equal(or3s(ung >= 1L, m %in% 1:4, h > 1L),
bor3(ung >= 1L, m %in% 1:4, h > 1L))
expect_equal(or3s(unh >= 9L, e %in% 1:4, c > 9L),
bor3(unh >= 9L, e %in% 1:4, c > 9L))
expect_equal(or3s(uni >= 0L, , ),
bor3(uni >= 0L, , ))
expect_equal(or3s(unj >= 1L, , ),
bor3(unj >= 1L, , ))
expect_equal(or3s(unk >= 9L, , ),
bor3(unk >= 9L, , ))
expect_equal(or3s(unl >= 0L, , l >= 0L),
bor3(unl >= 0L, , l >= 0L))
expect_equal(or3s(unm >= 1L, , g >= 1L),
bor3(unm >= 1L, , g >= 1L))
expect_equal(or3s(unn >= 9L, , g >= 9L),
bor3(unn >= 9L, , g >= 9L))
expect_equal(or3s(uno >= 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(uno >= 0L, r %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(unp >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(unp >= 1L, x %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(unq >= 9L, n %in% c(4L, -3L, 2L, 7L, 8L), ),
bor3(unq >= 9L, n %in% c(4L, -3L, 2L, 7L, 8L), ))
expect_equal(or3s(unr >= 0L, x %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L),
bor3(unr >= 0L, x %in% c(4L, -3L, 2L, 7L, 8L), e >= 0L))
expect_equal(or3s(uns >= 1L, z %in% c(4L, -3L, 2L, 7L, 8L), k >= 1L),
bor3(uns >= 1L, z %in% c(4L, -3L, 2L, 7L, 8L), k >= 1L))
expect_equal(or3s(unt >= 9L, d %in% c(4L, -3L, 2L, 7L, 8L), p >= 9L),
bor3(unt >= 9L, d %in% c(4L, -3L, 2L, 7L, 8L), p >= 9L))
expect_equal(or3s(unu >= 0L, , ),
bor3(unu >= 0L, , ))
expect_equal(or3s(unv >= 1L, , ),
bor3(unv >= 1L, , ))
expect_equal(or3s(unw >= 9L, , ),
bor3(unw >= 9L, , ))
expect_equal(or3s(unx >= 0L, , o >= 0L),
bor3(unx >= 0L, , o >= 0L))
expect_equal(or3s(uny >= 1L, , z >= 1L),
bor3(uny >= 1L, , z >= 1L))
expect_equal(or3s(unz >= 9L, , q >= 9L),
bor3(unz >= 9L, , q >= 9L))
expect_equal(or3s(uoa >= 0L, b %in% 1:4, ),
bor3(uoa >= 0L, b %in% 1:4, ))
expect_equal(or3s(uob >= 1L, h %in% 1:4, ),
bor3(uob >= 1L, h %in% 1:4, ))
expect_equal(or3s(uoc >= 9L, i %in% 1:4, ),
bor3(uoc >= 9L, i %in% 1:4, ))
expect_equal(or3s(uod >= 0L, k %in% 1:4, k >= 0L),
bor3(uod >= 0L, k %in% 1:4, k >= 0L))
expect_equal(or3s(uoe >= 1L, p %in% 1:4, g >= 1L),
bor3(uoe >= 1L, p %in% 1:4, g >= 1L))
expect_equal(or3s(uof >= 9L, j %in% 1:4, k >= 9L),
bor3(uof >= 9L, j %in% 1:4, k >= 9L))
expect_equal(or3s(uog >= 0L, , ),
bor3(uog >= 0L, , ))
expect_equal(or3s(uoh >= 1L, , ),
bor3(uoh >= 1L, , ))
expect_equal(or3s(uoi >= 9L, , ),
bor3(uoi >= 9L, , ))
expect_equal(or3s(uoj >= 0L, , logi_o),
bor3(uoj >= 0L, , logi_o))
expect_equal(or3s(uok >= 1L, , logi_f),
bor3(uok >= 1L, , logi_f))
expect_equal(or3s(uol >= 9L, , logi_v),
bor3(uol >= 9L, , logi_v))
expect_equal(or3s(uom >= 0L, u < 0L, ),
bor3(uom >= 0L, u < 0L, ))
expect_equal(or3s(uon >= 1L, j < 1L, ),
bor3(uon >= 1L, j < 1L, ))
expect_equal(or3s(uoo >= 9L, e < 9L, ),
bor3(uoo >= 9L, e < 9L, ))
expect_equal(or3s(uop >= 0L, n < 0L, logi_q),
bor3(uop >= 0L, n < 0L, logi_q))
expect_equal(or3s(uoq >= 1L, b < 1L, logi_b),
bor3(uoq >= 1L, b < 1L, logi_b))
expect_equal(or3s(uor >= 9L, h < 9L, logi_t),
bor3(uor >= 9L, h < 9L, logi_t))
expect_equal(or3s(uos >= 0L, , ),
bor3(uos >= 0L, , ))
expect_equal(or3s(uot >= 1L, , ),
bor3(uot >= 1L, , ))
expect_equal(or3s(uou >= 9L, , ),
bor3(uou >= 9L, , ))
expect_equal(or3s(uov >= 0L, , !logi_y),
bor3(uov >= 0L, , !logi_y))
expect_equal(or3s(uow >= 1L, , !logi_i),
bor3(uow >= 1L, , !logi_i))
expect_equal(or3s(uox >= 9L, , !logi_u),
bor3(uox >= 9L, , !logi_u))
expect_equal(or3s(uoy >= 0L, b < 0L, ),
bor3(uoy >= 0L, b < 0L, ))
expect_equal(or3s(uoz >= 1L, b < 1L, ),
bor3(uoz >= 1L, b < 1L, ))
expect_equal(or3s(upa >= 9L, e < 9L, ),
bor3(upa >= 9L, e < 9L, ))
expect_equal(or3s(upb >= 0L, h < 0L, !logi_u),
bor3(upb >= 0L, h < 0L, !logi_u))
expect_equal(or3s(upc >= 1L, n < 1L, !logi_l),
bor3(upc >= 1L, n < 1L, !logi_l))
expect_equal(or3s(upd >= 9L, g < 9L, !logi_f),
bor3(upd >= 9L, g < 9L, !logi_f))
expect_equal(or3s(upe >= 0L, , ),
bor3(upe >= 0L, , ))
expect_equal(or3s(upf >= 1L, , ),
bor3(upf >= 1L, , ))
expect_equal(or3s(upg >= 9L, , ),
bor3(upg >= 9L, , ))
expect_equal(or3s(uph >= 0L, , p != 0L),
bor3(uph >= 0L, , p != 0L))
expect_equal(or3s(upi >= 1L, , w != 1L),
bor3(upi >= 1L, , w != 1L))
expect_equal(or3s(upj >= 9L, , k != 9L),
bor3(upj >= 9L, , k != 9L))
expect_equal(or3s(upk >= 0L, j < 0L, ),
bor3(upk >= 0L, j < 0L, ))
expect_equal(or3s(upl >= 1L, z < 1L, ),
bor3(upl >= 1L, z < 1L, ))
expect_equal(or3s(upm >= 9L, p < 9L, ),
bor3(upm >= 9L, p < 9L, ))
expect_equal(or3s(upn >= 0L, j < 0L, o != 0L),
bor3(upn >= 0L, j < 0L, o != 0L))
expect_equal(or3s(upo >= 1L, m < 1L, f != 1L),
bor3(upo >= 1L, m < 1L, f != 1L))
expect_equal(or3s(upp >= 9L, s < 9L, g != 9L),
bor3(upp >= 9L, s < 9L, g != 9L))
expect_equal(or3s(upq >= 0L, , ),
bor3(upq >= 0L, , ))
expect_equal(or3s(upr >= 1L, , ),
bor3(upr >= 1L, , ))
expect_equal(or3s(ups >= 9L, , ),
bor3(ups >= 9L, , ))
expect_equal(or3s(upt >= 0L, , g %between% c(-1L, 1L)),
bor3(upt >= 0L, , g %between% c(-1L, 1L)))
expect_equal(or3s(upu >= 1L, , d %between% c(-1L, 1L)),
bor3(upu >= 1L, , d %between% c(-1L, 1L)))
expect_equal(or3s(upv >= 9L, , x %between% c(-1L, 1L)),
bor3(upv >= 9L, , x %between% c(-1L, 1L)))
expect_equal(or3s(upw >= 0L, l < 0L, ),
bor3(upw >= 0L, l < 0L, ))
expect_equal(or3s(upx >= 1L, e < 1L, ),
bor3(upx >= 1L, e < 1L, ))
expect_equal(or3s(upy >= 9L, t < 9L, ),
bor3(upy >= 9L, t < 9L, ))
expect_equal(or3s(upz >= 0L, w < 0L, f %between% c(-1L, 1L)),
bor3(upz >= 0L, w < 0L, f %between% c(-1L, 1L)))
expect_equal(or3s(uqa >= 1L, s < 1L, o %between% c(-1L, 1L)),
bor3(uqa >= 1L, s < 1L, o %between% c(-1L, 1L)))
expect_equal(or3s(uqb >= 9L, q < 9L, v %between% c(-1L, 1L)),
bor3(uqb >= 9L, q < 9L, v %between% c(-1L, 1L)))
expect_equal(or3s(uqc >= 0L, , ),
bor3(uqc >= 0L, , ))
expect_equal(or3s(uqd >= 1L, , ),
bor3(uqd >= 1L, , ))
expect_equal(or3s(uqe >= 9L, , ),
bor3(uqe >= 9L, , ))
expect_equal(or3s(uqf >= 0L, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uqf >= 0L, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uqg >= 1L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uqg >= 1L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uqh >= 9L, , j %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uqh >= 9L, , j %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uqi >= 0L, a < 0L, ),
bor3(uqi >= 0L, a < 0L, ))
expect_equal(or3s(uqj >= 1L, y < 1L, ),
bor3(uqj >= 1L, y < 1L, ))
expect_equal(or3s(uqk >= 9L, j < 9L, ),
bor3(uqk >= 9L, j < 9L, ))
expect_equal(or3s(uql >= 0L, r < 0L, v %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uql >= 0L, r < 0L, v %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uqm >= 1L, o < 1L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uqm >= 1L, o < 1L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uqn >= 9L, d < 9L, f %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uqn >= 9L, d < 9L, f %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uqo >= 0L, , ),
bor3(uqo >= 0L, , ))
expect_equal(or3s(uqp >= 1L, , ),
bor3(uqp >= 1L, , ))
expect_equal(or3s(uqq >= 9L, , ),
bor3(uqq >= 9L, , ))
expect_equal(or3s(uqr >= 0L, , x %in% 1:4),
bor3(uqr >= 0L, , x %in% 1:4))
expect_equal(or3s(uqs >= 1L, , z %in% 1:4),
bor3(uqs >= 1L, , z %in% 1:4))
expect_equal(or3s(uqt >= 9L, , q %in% 1:4),
bor3(uqt >= 9L, , q %in% 1:4))
expect_equal(or3s(uqu >= 0L, t < 0L, ),
bor3(uqu >= 0L, t < 0L, ))
expect_equal(or3s(uqv >= 1L, d < 1L, ),
bor3(uqv >= 1L, d < 1L, ))
expect_equal(or3s(uqw >= 9L, i < 9L, ),
bor3(uqw >= 9L, i < 9L, ))
expect_equal(or3s(uqx >= 0L, m < 0L, a %in% 1:4),
bor3(uqx >= 0L, m < 0L, a %in% 1:4))
expect_equal(or3s(uqy >= 1L, q < 1L, x %in% 1:4),
bor3(uqy >= 1L, q < 1L, x %in% 1:4))
expect_equal(or3s(uqz >= 9L, l < 9L, l %in% 1:4),
bor3(uqz >= 9L, l < 9L, l %in% 1:4))
expect_equal(or3s(ura >= 0L, , ),
bor3(ura >= 0L, , ))
expect_equal(or3s(urb >= 1L, , ),
bor3(urb >= 1L, , ))
expect_equal(or3s(urc >= 9L, , ),
bor3(urc >= 9L, , ))
expect_equal(or3s(urd >= 0L, , i < 0L),
bor3(urd >= 0L, , i < 0L))
expect_equal(or3s(ure >= 1L, , k < 1L),
bor3(ure >= 1L, , k < 1L))
expect_equal(or3s(urf >= 9L, , r < 9L),
bor3(urf >= 9L, , r < 9L))
expect_equal(or3s(urg >= 0L, s < 0L, ),
bor3(urg >= 0L, s < 0L, ))
expect_equal(or3s(urh >= 1L, a < 1L, ),
bor3(urh >= 1L, a < 1L, ))
expect_equal(or3s(uri >= 9L, m < 9L, ),
bor3(uri >= 9L, m < 9L, ))
expect_equal(or3s(urj >= 0L, n < 0L, i < 0L),
bor3(urj >= 0L, n < 0L, i < 0L))
expect_equal(or3s(urk >= 1L, y < 1L, e < 1L),
bor3(urk >= 1L, y < 1L, e < 1L))
expect_equal(or3s(url >= 9L, d < 9L, s < 9L),
bor3(url >= 9L, d < 9L, s < 9L))
expect_equal(or3s(urm >= 0L, , ),
bor3(urm >= 0L, , ))
expect_equal(or3s(urn >= 1L, , ),
bor3(urn >= 1L, , ))
expect_equal(or3s(uro >= 9L, , ),
bor3(uro >= 9L, , ))
expect_equal(or3s(urp >= 0L, , w <= 0L),
bor3(urp >= 0L, , w <= 0L))
expect_equal(or3s(urq >= 1L, , g <= 1L),
bor3(urq >= 1L, , g <= 1L))
expect_equal(or3s(urr >= 9L, , s <= 9L),
bor3(urr >= 9L, , s <= 9L))
expect_equal(or3s(urs >= 0L, c < 0L, ),
bor3(urs >= 0L, c < 0L, ))
expect_equal(or3s(urt >= 1L, k < 1L, ),
bor3(urt >= 1L, k < 1L, ))
expect_equal(or3s(uru >= 9L, e < 9L, ),
bor3(uru >= 9L, e < 9L, ))
expect_equal(or3s(urv >= 0L, p < 0L, l <= 0L),
bor3(urv >= 0L, p < 0L, l <= 0L))
expect_equal(or3s(urw >= 1L, u < 1L, g <= 1L),
bor3(urw >= 1L, u < 1L, g <= 1L))
expect_equal(or3s(urx >= 9L, q < 9L, t <= 9L),
bor3(urx >= 9L, q < 9L, t <= 9L))
expect_equal(or3s(ury >= 0L, , ),
bor3(ury >= 0L, , ))
expect_equal(or3s(urz >= 1L, , ),
bor3(urz >= 1L, , ))
expect_equal(or3s(usa >= 9L, , ),
bor3(usa >= 9L, , ))
expect_equal(or3s(usb >= 0L, , y == 0L),
bor3(usb >= 0L, , y == 0L))
expect_equal(or3s(usc >= 1L, , u == 1L),
bor3(usc >= 1L, , u == 1L))
expect_equal(or3s(usd >= 9L, , h == 9L),
bor3(usd >= 9L, , h == 9L))
expect_equal(or3s(use >= 0L, k < 0L, ),
bor3(use >= 0L, k < 0L, ))
expect_equal(or3s(usf >= 1L, u < 1L, ),
bor3(usf >= 1L, u < 1L, ))
expect_equal(or3s(usg >= 9L, d < 9L, ),
bor3(usg >= 9L, d < 9L, ))
expect_equal(or3s(ush >= 0L, i < 0L, f == 0L),
bor3(ush >= 0L, i < 0L, f == 0L))
expect_equal(or3s(usi >= 1L, g < 1L, f == 1L),
bor3(usi >= 1L, g < 1L, f == 1L))
expect_equal(or3s(usj >= 9L, x < 9L, b == 9L),
bor3(usj >= 9L, x < 9L, b == 9L))
expect_equal(or3s(usk >= 0L, , ),
bor3(usk >= 0L, , ))
expect_equal(or3s(usl >= 1L, , ),
bor3(usl >= 1L, , ))
expect_equal(or3s(usm >= 9L, , ),
bor3(usm >= 9L, , ))
expect_equal(or3s(usn >= 0L, , m > 0L),
bor3(usn >= 0L, , m > 0L))
expect_equal(or3s(uso >= 1L, , x > 1L),
bor3(uso >= 1L, , x > 1L))
expect_equal(or3s(usp >= 9L, , d > 9L),
bor3(usp >= 9L, , d > 9L))
expect_equal(or3s(usq >= 0L, g < 0L, ),
bor3(usq >= 0L, g < 0L, ))
expect_equal(or3s(usr >= 1L, i < 1L, ),
bor3(usr >= 1L, i < 1L, ))
expect_equal(or3s(uss >= 9L, d < 9L, ),
bor3(uss >= 9L, d < 9L, ))
expect_equal(or3s(ust >= 0L, x < 0L, k > 0L),
bor3(ust >= 0L, x < 0L, k > 0L))
expect_equal(or3s(usu >= 1L, f < 1L, f > 1L),
bor3(usu >= 1L, f < 1L, f > 1L))
expect_equal(or3s(usv >= 9L, t < 9L, r > 9L),
bor3(usv >= 9L, t < 9L, r > 9L))
expect_equal(or3s(usw >= 0L, , ),
bor3(usw >= 0L, , ))
expect_equal(or3s(usx >= 1L, , ),
bor3(usx >= 1L, , ))
expect_equal(or3s(usy >= 9L, , ),
bor3(usy >= 9L, , ))
expect_equal(or3s(usz >= 0L, , x >= 0L),
bor3(usz >= 0L, , x >= 0L))
expect_equal(or3s(uta >= 1L, , y >= 1L),
bor3(uta >= 1L, , y >= 1L))
expect_equal(or3s(utb >= 9L, , k >= 9L),
bor3(utb >= 9L, , k >= 9L))
expect_equal(or3s(utc >= 0L, u < 0L, ),
bor3(utc >= 0L, u < 0L, ))
expect_equal(or3s(utd >= 1L, h < 1L, ),
bor3(utd >= 1L, h < 1L, ))
expect_equal(or3s(ute >= 9L, v < 9L, ),
bor3(ute >= 9L, v < 9L, ))
expect_equal(or3s(utf >= 0L, b < 0L, u >= 0L),
bor3(utf >= 0L, b < 0L, u >= 0L))
expect_equal(or3s(utg >= 1L, a < 1L, y >= 1L),
bor3(utg >= 1L, a < 1L, y >= 1L))
expect_equal(or3s(uth >= 9L, d < 9L, k >= 9L),
bor3(uth >= 9L, d < 9L, k >= 9L))
expect_equal(or3s(uti >= 0L, , ),
bor3(uti >= 0L, , ))
expect_equal(or3s(utj >= 1L, , ),
bor3(utj >= 1L, , ))
expect_equal(or3s(utk >= 9L, , ),
bor3(utk >= 9L, , ))
expect_equal(or3s(utl >= 0L, , logi_e),
bor3(utl >= 0L, , logi_e))
expect_equal(or3s(utm >= 1L, , logi_i),
bor3(utm >= 1L, , logi_i))
expect_equal(or3s(utn >= 9L, , logi_e),
bor3(utn >= 9L, , logi_e))
expect_equal(or3s(uto >= 0L, n <= 0L, ),
bor3(uto >= 0L, n <= 0L, ))
expect_equal(or3s(utp >= 1L, n <= 1L, ),
bor3(utp >= 1L, n <= 1L, ))
expect_equal(or3s(utq >= 9L, c <= 9L, ),
bor3(utq >= 9L, c <= 9L, ))
expect_equal(or3s(utr >= 0L, p <= 0L, logi_x),
bor3(utr >= 0L, p <= 0L, logi_x))
expect_equal(or3s(uts >= 1L, s <= 1L, logi_l),
bor3(uts >= 1L, s <= 1L, logi_l))
expect_equal(or3s(utt >= 9L, v <= 9L, logi_m),
bor3(utt >= 9L, v <= 9L, logi_m))
expect_equal(or3s(utu >= 0L, , ),
bor3(utu >= 0L, , ))
expect_equal(or3s(utv >= 1L, , ),
bor3(utv >= 1L, , ))
expect_equal(or3s(utw >= 9L, , ),
bor3(utw >= 9L, , ))
expect_equal(or3s(utx >= 0L, , !logi_h),
bor3(utx >= 0L, , !logi_h))
expect_equal(or3s(uty >= 1L, , !logi_o),
bor3(uty >= 1L, , !logi_o))
expect_equal(or3s(utz >= 9L, , !logi_b),
bor3(utz >= 9L, , !logi_b))
expect_equal(or3s(uua >= 0L, z <= 0L, ),
bor3(uua >= 0L, z <= 0L, ))
expect_equal(or3s(uub >= 1L, i <= 1L, ),
bor3(uub >= 1L, i <= 1L, ))
expect_equal(or3s(uuc >= 9L, i <= 9L, ),
bor3(uuc >= 9L, i <= 9L, ))
expect_equal(or3s(uud >= 0L, g <= 0L, !logi_e),
bor3(uud >= 0L, g <= 0L, !logi_e))
expect_equal(or3s(uue >= 1L, j <= 1L, !logi_p),
bor3(uue >= 1L, j <= 1L, !logi_p))
expect_equal(or3s(uuf >= 9L, u <= 9L, !logi_v),
bor3(uuf >= 9L, u <= 9L, !logi_v))
expect_equal(or3s(uug >= 0L, , ),
bor3(uug >= 0L, , ))
expect_equal(or3s(uuh >= 1L, , ),
bor3(uuh >= 1L, , ))
expect_equal(or3s(uui >= 9L, , ),
bor3(uui >= 9L, , ))
expect_equal(or3s(uuj >= 0L, , e != 0L),
bor3(uuj >= 0L, , e != 0L))
expect_equal(or3s(uuk >= 1L, , u != 1L),
bor3(uuk >= 1L, , u != 1L))
expect_equal(or3s(uul >= 9L, , i != 9L),
bor3(uul >= 9L, , i != 9L))
expect_equal(or3s(uum >= 0L, o <= 0L, ),
bor3(uum >= 0L, o <= 0L, ))
expect_equal(or3s(uun >= 1L, q <= 1L, ),
bor3(uun >= 1L, q <= 1L, ))
expect_equal(or3s(uuo >= 9L, p <= 9L, ),
bor3(uuo >= 9L, p <= 9L, ))
expect_equal(or3s(uup >= 0L, j <= 0L, l != 0L),
bor3(uup >= 0L, j <= 0L, l != 0L))
expect_equal(or3s(uuq >= 1L, b <= 1L, t != 1L),
bor3(uuq >= 1L, b <= 1L, t != 1L))
expect_equal(or3s(uur >= 9L, r <= 9L, f != 9L),
bor3(uur >= 9L, r <= 9L, f != 9L))
expect_equal(or3s(uus >= 0L, , ),
bor3(uus >= 0L, , ))
expect_equal(or3s(uut >= 1L, , ),
bor3(uut >= 1L, , ))
expect_equal(or3s(uuu >= 9L, , ),
bor3(uuu >= 9L, , ))
expect_equal(or3s(uuv >= 0L, , a %between% c(-1L, 1L)),
bor3(uuv >= 0L, , a %between% c(-1L, 1L)))
expect_equal(or3s(uuw >= 1L, , f %between% c(-1L, 1L)),
bor3(uuw >= 1L, , f %between% c(-1L, 1L)))
expect_equal(or3s(uux >= 9L, , g %between% c(-1L, 1L)),
bor3(uux >= 9L, , g %between% c(-1L, 1L)))
expect_equal(or3s(uuy >= 0L, k <= 0L, ),
bor3(uuy >= 0L, k <= 0L, ))
expect_equal(or3s(uuz >= 1L, r <= 1L, ),
bor3(uuz >= 1L, r <= 1L, ))
expect_equal(or3s(uva >= 9L, x <= 9L, ),
bor3(uva >= 9L, x <= 9L, ))
expect_equal(or3s(uvb >= 0L, r <= 0L, z %between% c(-1L, 1L)),
bor3(uvb >= 0L, r <= 0L, z %between% c(-1L, 1L)))
expect_equal(or3s(uvc >= 1L, w <= 1L, j %between% c(-1L, 1L)),
bor3(uvc >= 1L, w <= 1L, j %between% c(-1L, 1L)))
expect_equal(or3s(uvd >= 9L, w <= 9L, w %between% c(-1L, 1L)),
bor3(uvd >= 9L, w <= 9L, w %between% c(-1L, 1L)))
expect_equal(or3s(uve >= 0L, , ),
bor3(uve >= 0L, , ))
expect_equal(or3s(uvf >= 1L, , ),
bor3(uvf >= 1L, , ))
expect_equal(or3s(uvg >= 9L, , ),
bor3(uvg >= 9L, , ))
expect_equal(or3s(uvh >= 0L, , l %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uvh >= 0L, , l %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uvi >= 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uvi >= 1L, , e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uvj >= 9L, , k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uvj >= 9L, , k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uvk >= 0L, p <= 0L, ),
bor3(uvk >= 0L, p <= 0L, ))
expect_equal(or3s(uvl >= 1L, w <= 1L, ),
bor3(uvl >= 1L, w <= 1L, ))
expect_equal(or3s(uvm >= 9L, f <= 9L, ),
bor3(uvm >= 9L, f <= 9L, ))
expect_equal(or3s(uvn >= 0L, m <= 0L, k %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uvn >= 0L, m <= 0L, k %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uvo >= 1L, c <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uvo >= 1L, c <= 1L, d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uvp >= 9L, p <= 9L, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(uvp >= 9L, p <= 9L, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(uvq >= 0L, , ),
bor3(uvq >= 0L, , ))
expect_equal(or3s(uvr >= 1L, , ),
bor3(uvr >= 1L, , ))
expect_equal(or3s(uvs >= 9L, , ),
bor3(uvs >= 9L, , ))
expect_equal(or3s(uvt >= 0L, , k %in% 1:4),
bor3(uvt >= 0L, , k %in% 1:4))
expect_equal(or3s(uvu >= 1L, , c %in% 1:4),
bor3(uvu >= 1L, , c %in% 1:4))
expect_equal(or3s(uvv >= 9L, , u %in% 1:4),
bor3(uvv >= 9L, , u %in% 1:4))
expect_equal(or3s(uvw >= 0L, h <= 0L, ),
bor3(uvw >= 0L, h <= 0L, ))
expect_equal(or3s(uvx >= 1L, o <= 1L, ),
bor3(uvx >= 1L, o <= 1L, ))
expect_equal(or3s(uvy >= 9L, m <= 9L, ),
bor3(uvy >= 9L, m <= 9L, ))
expect_equal(or3s(uvz >= 0L, a <= 0L, x %in% 1:4),
bor3(uvz >= 0L, a <= 0L, x %in% 1:4))
expect_equal(or3s(uwa >= 1L, p <= 1L, b %in% 1:4),
bor3(uwa >= 1L, p <= 1L, b %in% 1:4))
expect_equal(or3s(uwb >= 9L, p <= 9L, j %in% 1:4),
bor3(uwb >= 9L, p <= 9L, j %in% 1:4))
expect_equal(or3s(uwc >= 0L, , ),
bor3(uwc >= 0L, , ))
expect_equal(or3s(uwd >= 1L, , ),
bor3(uwd >= 1L, , ))
expect_equal(or3s(uwe >= 9L, , ),
bor3(uwe >= 9L, , ))
expect_equal(or3s(uwf >= 0L, , j < 0L),
bor3(uwf >= 0L, , j < 0L))
expect_equal(or3s(uwg >= 1L, , j < 1L),
bor3(uwg >= 1L, , j < 1L))
expect_equal(or3s(uwh >= 9L, , m < 9L),
bor3(uwh >= 9L, , m < 9L))
expect_equal(or3s(uwi >= 0L, i <= 0L, ),
bor3(uwi >= 0L, i <= 0L, ))
expect_equal(or3s(uwj >= 1L, z <= 1L, ),
bor3(uwj >= 1L, z <= 1L, ))
expect_equal(or3s(uwk >= 9L, g <= 9L, ),
bor3(uwk >= 9L, g <= 9L, ))
expect_equal(or3s(uwl >= 0L, g <= 0L, m < 0L),
bor3(uwl >= 0L, g <= 0L, m < 0L))
expect_equal(or3s(uwm >= 1L, l <= 1L, i < 1L),
bor3(uwm >= 1L, l <= 1L, i < 1L))
expect_equal(or3s(uwn >= 9L, z <= 9L, f < 9L),
bor3(uwn >= 9L, z <= 9L, f < 9L))
expect_equal(or3s(uwo >= 0L, , ),
bor3(uwo >= 0L, , ))
expect_equal(or3s(uwp >= 1L, , ),
bor3(uwp >= 1L, , ))
expect_equal(or3s(uwq >= 9L, , ),
bor3(uwq >= 9L, , ))
expect_equal(or3s(uwr >= 0L, , x <= 0L),
bor3(uwr >= 0L, , x <= 0L))
expect_equal(or3s(uws >= 1L, , r <= 1L),
bor3(uws >= 1L, , r <= 1L))
expect_equal(or3s(uwt >= 9L, , i <= 9L),
bor3(uwt >= 9L, , i <= 9L))
expect_equal(or3s(uwu >= 0L, h <= 0L, ),
bor3(uwu >= 0L, h <= 0L, ))
expect_equal(or3s(uwv >= 1L, l <= 1L, ),
bor3(uwv >= 1L, l <= 1L, ))
expect_equal(or3s(uww >= 9L, m <= 9L, ),
bor3(uww >= 9L, m <= 9L, ))
expect_equal(or3s(uwx >= 0L, h <= 0L, z <= 0L),
bor3(uwx >= 0L, h <= 0L, z <= 0L))
expect_equal(or3s(uwy >= 1L, q <= 1L, y <= 1L),
bor3(uwy >= 1L, q <= 1L, y <= 1L))
expect_equal(or3s(uwz >= 9L, i <= 9L, h <= 9L),
bor3(uwz >= 9L, i <= 9L, h <= 9L))
expect_equal(or3s(uxa >= 0L, , ),
bor3(uxa >= 0L, , ))
expect_equal(or3s(uxb >= 1L, , ),
bor3(uxb >= 1L, , ))
expect_equal(or3s(uxc >= 9L, , ),
bor3(uxc >= 9L, , ))
expect_equal(or3s(uxd >= 0L, , s == 0L),
bor3(uxd >= 0L, , s == 0L))
expect_equal(or3s(uxe >= 1L, , n == 1L),
bor3(uxe >= 1L, , n == 1L))
expect_equal(or3s(uxf >= 9L, , i == 9L),
bor3(uxf >= 9L, , i == 9L))
expect_equal(or3s(uxg >= 0L, o <= 0L, ),
bor3(uxg >= 0L, o <= 0L, ))
expect_equal(or3s(uxh >= 1L, b <= 1L, ),
bor3(uxh >= 1L, b <= 1L, ))
expect_equal(or3s(uxi >= 9L, s <= 9L, ),
bor3(uxi >= 9L, s <= 9L, ))
expect_equal(or3s(uxj >= 0L, v <= 0L, j == 0L),
bor3(uxj >= 0L, v <= 0L, j == 0L))
expect_equal(or3s(uxk >= 1L, t <= 1L, d == 1L),
bor3(uxk >= 1L, t <= 1L, d == 1L))
expect_equal(or3s(uxl >= 9L, i <= 9L, s == 9L),
bor3(uxl >= 9L, i <= 9L, s == 9L))
expect_equal(or3s(uxm >= 0L, , ),
bor3(uxm >= 0L, , ))
expect_equal(or3s(uxn >= 1L, , ),
bor3(uxn >= 1L, , ))
expect_equal(or3s(uxo >= 9L, , ),
bor3(uxo >= 9L, , ))
expect_equal(or3s(uxp >= 0L, , i > 0L),
bor3(uxp >= 0L, , i > 0L))
expect_equal(or3s(uxq >= 1L, , z > 1L),
bor3(uxq >= 1L, , z > 1L))
expect_equal(or3s(uxr >= 9L, , c > 9L),
bor3(uxr >= 9L, , c > 9L))
expect_equal(or3s(uxs >= 0L, s <= 0L, ),
bor3(uxs >= 0L, s <= 0L, ))
expect_equal(or3s(uxt >= 1L, p <= 1L, ),
bor3(uxt >= 1L, p <= 1L, ))
expect_equal(or3s(uxu >= 9L, z <= 9L, ),
bor3(uxu >= 9L, z <= 9L, ))
expect_equal(or3s(uxv >= 0L, n <= 0L, w > 0L),
bor3(uxv >= 0L, n <= 0L, w > 0L))
expect_equal(or3s(uxw >= 1L, t <= 1L, p > 1L),
bor3(uxw >= 1L, t <= 1L, p > 1L))
expect_equal(or3s(uxx >= 9L, o <= 9L, m > 9L),
bor3(uxx >= 9L, o <= 9L, m > 9L))
expect_equal(or3s(uxy >= 0L, , ),
bor3(uxy >= 0L, , ))
expect_equal(or3s(uxz >= 1L, , ),
bor3(uxz >= 1L, , ))
expect_equal(or3s(uya >= 9L, , ),
bor3(uya >= 9L, , ))
expect_equal(or3s(uyb >= 0L, , y >= 0L),
bor3(uyb >= 0L, , y >= 0L))
expect_equal(or3s(uyc >= 1L, , z >= 1L),
bor3(uyc >= 1L, , z >= 1L))
expect_equal(or3s(uyd >= 9L, , m >= 9L),
bor3(uyd >= 9L, , m >= 9L))
expect_equal(or3s(uye >= 0L, g <= 0L, ),
bor3(uye >= 0L, g <= 0L, ))
expect_equal(or3s(uyf >= 1L, b <= 1L, ),
bor3(uyf >= 1L, b <= 1L, ))
expect_equal(or3s(uyg >= 9L, w <= 9L, ),
bor3(uyg >= 9L, w <= 9L, ))
expect_equal(or3s(uyh >= 0L, s <= 0L, x >= 0L),
bor3(uyh >= 0L, s <= 0L, x >= 0L))
expect_equal(or3s(uyi >= 1L, z <= 1L, z >= 1L),
bor3(uyi >= 1L, z <= 1L, z >= 1L))
expect_equal(or3s(uyj >= 9L, i <= 9L, s >= 9L),
bor3(uyj >= 9L, i <= 9L, s >= 9L))
expect_equal(or3s(uyk >= 0L, , ),
bor3(uyk >= 0L, , ))
expect_equal(or3s(uyl >= 1L, , ),
bor3(uyl >= 1L, , ))
expect_equal(or3s(uym >= 9L, , ),
bor3(uym >= 9L, , ))
expect_equal(or3s(uyn >= 0L, , logi_z),
bor3(uyn >= 0L, , logi_z))
expect_equal(or3s(uyo >= 1L, , logi_m),
bor3(uyo >= 1L, , logi_m))
expect_equal(or3s(uyp >= 9L, , logi_u),
bor3(uyp >= 9L, , logi_u))
expect_equal(or3s(uyq >= 0L, m == 0L, ),
bor3(uyq >= 0L, m == 0L, ))
expect_equal(or3s(uyr >= 1L, t == 1L, ),
bor3(uyr >= 1L, t == 1L, ))
expect_equal(or3s(uys >= 9L, l == 9L, ),
bor3(uys >= 9L, l == 9L, ))
expect_equal(or3s(uyt >= 0L, i == 0L, logi_m),
bor3(uyt >= 0L, i == 0L, logi_m))
expect_equal(or3s(uyu >= 1L, c == 1L, logi_l),
bor3(uyu >= 1L, c == 1L, logi_l))
expect_equal(or3s(uyv >= 9L, y == 9L, logi_l),
bor3(uyv >= 9L, y == 9L, logi_l))
expect_equal(or3s(uyw >= 0L, , ),
bor3(uyw >= 0L, , ))
expect_equal(or3s(uyx >= 1L, , ),
bor3(uyx >= 1L, , ))
expect_equal(or3s(uyy >= 9L, , ),
bor3(uyy >= 9L, , ))
expect_equal(or3s(uyz >= 0L, , !logi_o),
bor3(uyz >= 0L, , !logi_o))
expect_equal(or3s(va >= 1L, , !logi_a),
bor3(va >= 1L, , !logi_a))
expect_equal(or3s(vb >= 9L, , !logi_i),
bor3(vb >= 9L, , !logi_i))
expect_equal(or3s(vc >= 0L, f == 0L, ),
bor3(vc >= 0L, f == 0L, ))
expect_equal(or3s(vd >= 1L, g == 1L, ),
bor3(vd >= 1L, g == 1L, ))
expect_equal(or3s(ve >= 9L, q == 9L, ),
bor3(ve >= 9L, q == 9L, ))
expect_equal(or3s(vf >= 0L, f == 0L, !logi_e),
bor3(vf >= 0L, f == 0L, !logi_e))
expect_equal(or3s(vg >= 1L, s == 1L, !logi_a),
bor3(vg >= 1L, s == 1L, !logi_a))
expect_equal(or3s(vh >= 9L, q == 9L, !logi_a),
bor3(vh >= 9L, q == 9L, !logi_a))
expect_equal(or3s(vi >= 0L, , ),
bor3(vi >= 0L, , ))
expect_equal(or3s(vj >= 1L, , ),
bor3(vj >= 1L, , ))
expect_equal(or3s(vk >= 9L, , ),
bor3(vk >= 9L, , ))
expect_equal(or3s(vl >= 0L, , i != 0L),
bor3(vl >= 0L, , i != 0L))
expect_equal(or3s(vm >= 1L, , z != 1L),
bor3(vm >= 1L, , z != 1L))
expect_equal(or3s(vn >= 9L, , i != 9L),
bor3(vn >= 9L, , i != 9L))
expect_equal(or3s(vo >= 0L, m == 0L, ),
bor3(vo >= 0L, m == 0L, ))
expect_equal(or3s(vp >= 1L, v == 1L, ),
bor3(vp >= 1L, v == 1L, ))
expect_equal(or3s(vq >= 9L, e == 9L, ),
bor3(vq >= 9L, e == 9L, ))
expect_equal(or3s(vr >= 0L, i == 0L, h != 0L),
bor3(vr >= 0L, i == 0L, h != 0L))
expect_equal(or3s(vs >= 1L, q == 1L, q != 1L),
bor3(vs >= 1L, q == 1L, q != 1L))
expect_equal(or3s(vt >= 9L, k == 9L, p != 9L),
bor3(vt >= 9L, k == 9L, p != 9L))
expect_equal(or3s(vu >= 0L, , ),
bor3(vu >= 0L, , ))
expect_equal(or3s(vv >= 1L, , ),
bor3(vv >= 1L, , ))
expect_equal(or3s(vw >= 9L, , ),
bor3(vw >= 9L, , ))
expect_equal(or3s(vx >= 0L, , z %between% c(-1L, 1L)),
bor3(vx >= 0L, , z %between% c(-1L, 1L)))
expect_equal(or3s(vy >= 1L, , q %between% c(-1L, 1L)),
bor3(vy >= 1L, , q %between% c(-1L, 1L)))
expect_equal(or3s(vz >= 9L, , v %between% c(-1L, 1L)),
bor3(vz >= 9L, , v %between% c(-1L, 1L)))
expect_equal(or3s(vaa >= 0L, g == 0L, ),
bor3(vaa >= 0L, g == 0L, ))
expect_equal(or3s(vab >= 1L, x == 1L, ),
bor3(vab >= 1L, x == 1L, ))
expect_equal(or3s(vac >= 9L, u == 9L, ),
bor3(vac >= 9L, u == 9L, ))
expect_equal(or3s(vad >= 0L, t == 0L, b %between% c(-1L, 1L)),
bor3(vad >= 0L, t == 0L, b %between% c(-1L, 1L)))
expect_equal(or3s(vae >= 1L, r == 1L, h %between% c(-1L, 1L)),
bor3(vae >= 1L, r == 1L, h %between% c(-1L, 1L)))
expect_equal(or3s(vaf >= 9L, i == 9L, a %between% c(-1L, 1L)),
bor3(vaf >= 9L, i == 9L, a %between% c(-1L, 1L)))
expect_equal(or3s(vag >= 0L, , ),
bor3(vag >= 0L, , ))
expect_equal(or3s(vah >= 1L, , ),
bor3(vah >= 1L, , ))
expect_equal(or3s(vai >= 9L, , ),
bor3(vai >= 9L, , ))
expect_equal(or3s(vaj >= 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vaj >= 0L, , g %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vak >= 1L, , u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vak >= 1L, , u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(val >= 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(val >= 9L, , a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vam >= 0L, b == 0L, ),
bor3(vam >= 0L, b == 0L, ))
expect_equal(or3s(van >= 1L, a == 1L, ),
bor3(van >= 1L, a == 1L, ))
expect_equal(or3s(vao >= 9L, g == 9L, ),
bor3(vao >= 9L, g == 9L, ))
expect_equal(or3s(vap >= 0L, k == 0L, u %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vap >= 0L, k == 0L, u %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vaq >= 1L, j == 1L, t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vaq >= 1L, j == 1L, t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(var >= 9L, a == 9L, e %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(var >= 9L, a == 9L, e %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vas >= 0L, , ),
bor3(vas >= 0L, , ))
expect_equal(or3s(vat >= 1L, , ),
bor3(vat >= 1L, , ))
expect_equal(or3s(vau >= 9L, , ),
bor3(vau >= 9L, , ))
expect_equal(or3s(vav >= 0L, , k %in% 1:4),
bor3(vav >= 0L, , k %in% 1:4))
expect_equal(or3s(vaw >= 1L, , s %in% 1:4),
bor3(vaw >= 1L, , s %in% 1:4))
expect_equal(or3s(vax >= 9L, , l %in% 1:4),
bor3(vax >= 9L, , l %in% 1:4))
expect_equal(or3s(vay >= 0L, w == 0L, ),
bor3(vay >= 0L, w == 0L, ))
expect_equal(or3s(vaz >= 1L, e == 1L, ),
bor3(vaz >= 1L, e == 1L, ))
expect_equal(or3s(vba >= 9L, f == 9L, ),
bor3(vba >= 9L, f == 9L, ))
expect_equal(or3s(vbb >= 0L, g == 0L, v %in% 1:4),
bor3(vbb >= 0L, g == 0L, v %in% 1:4))
expect_equal(or3s(vbc >= 1L, i == 1L, g %in% 1:4),
bor3(vbc >= 1L, i == 1L, g %in% 1:4))
expect_equal(or3s(vbd >= 9L, u == 9L, b %in% 1:4),
bor3(vbd >= 9L, u == 9L, b %in% 1:4))
expect_equal(or3s(vbe >= 0L, , ),
bor3(vbe >= 0L, , ))
expect_equal(or3s(vbf >= 1L, , ),
bor3(vbf >= 1L, , ))
expect_equal(or3s(vbg >= 9L, , ),
bor3(vbg >= 9L, , ))
expect_equal(or3s(vbh >= 0L, , k < 0L),
bor3(vbh >= 0L, , k < 0L))
expect_equal(or3s(vbi >= 1L, , e < 1L),
bor3(vbi >= 1L, , e < 1L))
expect_equal(or3s(vbj >= 9L, , h < 9L),
bor3(vbj >= 9L, , h < 9L))
expect_equal(or3s(vbk >= 0L, f == 0L, ),
bor3(vbk >= 0L, f == 0L, ))
expect_equal(or3s(vbl >= 1L, z == 1L, ),
bor3(vbl >= 1L, z == 1L, ))
expect_equal(or3s(vbm >= 9L, r == 9L, ),
bor3(vbm >= 9L, r == 9L, ))
expect_equal(or3s(vbn >= 0L, g == 0L, x < 0L),
bor3(vbn >= 0L, g == 0L, x < 0L))
expect_equal(or3s(vbo >= 1L, z == 1L, u < 1L),
bor3(vbo >= 1L, z == 1L, u < 1L))
expect_equal(or3s(vbp >= 9L, c == 9L, b < 9L),
bor3(vbp >= 9L, c == 9L, b < 9L))
expect_equal(or3s(vbq >= 0L, , ),
bor3(vbq >= 0L, , ))
expect_equal(or3s(vbr >= 1L, , ),
bor3(vbr >= 1L, , ))
expect_equal(or3s(vbs >= 9L, , ),
bor3(vbs >= 9L, , ))
expect_equal(or3s(vbt >= 0L, , u <= 0L),
bor3(vbt >= 0L, , u <= 0L))
expect_equal(or3s(vbu >= 1L, , q <= 1L),
bor3(vbu >= 1L, , q <= 1L))
expect_equal(or3s(vbv >= 9L, , z <= 9L),
bor3(vbv >= 9L, , z <= 9L))
expect_equal(or3s(vbw >= 0L, j == 0L, ),
bor3(vbw >= 0L, j == 0L, ))
expect_equal(or3s(vbx >= 1L, b == 1L, ),
bor3(vbx >= 1L, b == 1L, ))
expect_equal(or3s(vby >= 9L, x == 9L, ),
bor3(vby >= 9L, x == 9L, ))
expect_equal(or3s(vbz >= 0L, t == 0L, j <= 0L),
bor3(vbz >= 0L, t == 0L, j <= 0L))
expect_equal(or3s(vca >= 1L, s == 1L, u <= 1L),
bor3(vca >= 1L, s == 1L, u <= 1L))
expect_equal(or3s(vcb >= 9L, j == 9L, f <= 9L),
bor3(vcb >= 9L, j == 9L, f <= 9L))
expect_equal(or3s(vcc >= 0L, , ),
bor3(vcc >= 0L, , ))
expect_equal(or3s(vcd >= 1L, , ),
bor3(vcd >= 1L, , ))
expect_equal(or3s(vce >= 9L, , ),
bor3(vce >= 9L, , ))
expect_equal(or3s(vcf >= 0L, , f == 0L),
bor3(vcf >= 0L, , f == 0L))
expect_equal(or3s(vcg >= 1L, , t == 1L),
bor3(vcg >= 1L, , t == 1L))
expect_equal(or3s(vch >= 9L, , y == 9L),
bor3(vch >= 9L, , y == 9L))
expect_equal(or3s(vci >= 0L, u == 0L, ),
bor3(vci >= 0L, u == 0L, ))
expect_equal(or3s(vcj >= 1L, u == 1L, ),
bor3(vcj >= 1L, u == 1L, ))
expect_equal(or3s(vck >= 9L, r == 9L, ),
bor3(vck >= 9L, r == 9L, ))
expect_equal(or3s(vcl >= 0L, e == 0L, k == 0L),
bor3(vcl >= 0L, e == 0L, k == 0L))
expect_equal(or3s(vcm >= 1L, e == 1L, a == 1L),
bor3(vcm >= 1L, e == 1L, a == 1L))
expect_equal(or3s(vcn >= 9L, n == 9L, d == 9L),
bor3(vcn >= 9L, n == 9L, d == 9L))
expect_equal(or3s(vco >= 0L, , ),
bor3(vco >= 0L, , ))
expect_equal(or3s(vcp >= 1L, , ),
bor3(vcp >= 1L, , ))
expect_equal(or3s(vcq >= 9L, , ),
bor3(vcq >= 9L, , ))
expect_equal(or3s(vcr >= 0L, , r > 0L),
bor3(vcr >= 0L, , r > 0L))
expect_equal(or3s(vcs >= 1L, , g > 1L),
bor3(vcs >= 1L, , g > 1L))
expect_equal(or3s(vct >= 9L, , d > 9L),
bor3(vct >= 9L, , d > 9L))
expect_equal(or3s(vcu >= 0L, e == 0L, ),
bor3(vcu >= 0L, e == 0L, ))
expect_equal(or3s(vcv >= 1L, t == 1L, ),
bor3(vcv >= 1L, t == 1L, ))
expect_equal(or3s(vcw >= 9L, t == 9L, ),
bor3(vcw >= 9L, t == 9L, ))
expect_equal(or3s(vcx >= 0L, e == 0L, s > 0L),
bor3(vcx >= 0L, e == 0L, s > 0L))
expect_equal(or3s(vcy >= 1L, f == 1L, w > 1L),
bor3(vcy >= 1L, f == 1L, w > 1L))
expect_equal(or3s(vcz >= 9L, i == 9L, n > 9L),
bor3(vcz >= 9L, i == 9L, n > 9L))
expect_equal(or3s(vda >= 0L, , ),
bor3(vda >= 0L, , ))
expect_equal(or3s(vdb >= 1L, , ),
bor3(vdb >= 1L, , ))
expect_equal(or3s(vdc >= 9L, , ),
bor3(vdc >= 9L, , ))
expect_equal(or3s(vdd >= 0L, , k >= 0L),
bor3(vdd >= 0L, , k >= 0L))
expect_equal(or3s(vde >= 1L, , u >= 1L),
bor3(vde >= 1L, , u >= 1L))
expect_equal(or3s(vdf >= 9L, , s >= 9L),
bor3(vdf >= 9L, , s >= 9L))
expect_equal(or3s(vdg >= 0L, t == 0L, ),
bor3(vdg >= 0L, t == 0L, ))
expect_equal(or3s(vdh >= 1L, a == 1L, ),
bor3(vdh >= 1L, a == 1L, ))
expect_equal(or3s(vdi >= 9L, x == 9L, ),
bor3(vdi >= 9L, x == 9L, ))
expect_equal(or3s(vdj >= 0L, p == 0L, b >= 0L),
bor3(vdj >= 0L, p == 0L, b >= 0L))
expect_equal(or3s(vdk >= 1L, b == 1L, f >= 1L),
bor3(vdk >= 1L, b == 1L, f >= 1L))
expect_equal(or3s(vdl >= 9L, j == 9L, t >= 9L),
bor3(vdl >= 9L, j == 9L, t >= 9L))
expect_equal(or3s(vdm >= 0L, , ),
bor3(vdm >= 0L, , ))
expect_equal(or3s(vdn >= 1L, , ),
bor3(vdn >= 1L, , ))
expect_equal(or3s(vdo >= 9L, , ),
bor3(vdo >= 9L, , ))
expect_equal(or3s(vdp >= 0L, , logi_f),
bor3(vdp >= 0L, , logi_f))
expect_equal(or3s(vdq >= 1L, , logi_n),
bor3(vdq >= 1L, , logi_n))
expect_equal(or3s(vdr >= 9L, , logi_h),
bor3(vdr >= 9L, , logi_h))
expect_equal(or3s(vds >= 0L, h > 0L, ),
bor3(vds >= 0L, h > 0L, ))
expect_equal(or3s(vdt >= 1L, t > 1L, ),
bor3(vdt >= 1L, t > 1L, ))
expect_equal(or3s(vdu >= 9L, c > 9L, ),
bor3(vdu >= 9L, c > 9L, ))
expect_equal(or3s(vdv >= 0L, v > 0L, logi_n),
bor3(vdv >= 0L, v > 0L, logi_n))
expect_equal(or3s(vdw >= 1L, o > 1L, logi_a),
bor3(vdw >= 1L, o > 1L, logi_a))
expect_equal(or3s(vdx >= 9L, k > 9L, logi_v),
bor3(vdx >= 9L, k > 9L, logi_v))
expect_equal(or3s(vdy >= 0L, , ),
bor3(vdy >= 0L, , ))
expect_equal(or3s(vdz >= 1L, , ),
bor3(vdz >= 1L, , ))
expect_equal(or3s(vea >= 9L, , ),
bor3(vea >= 9L, , ))
expect_equal(or3s(veb >= 0L, , !logi_d),
bor3(veb >= 0L, , !logi_d))
expect_equal(or3s(vec >= 1L, , !logi_n),
bor3(vec >= 1L, , !logi_n))
expect_equal(or3s(ved >= 9L, , !logi_u),
bor3(ved >= 9L, , !logi_u))
expect_equal(or3s(vee >= 0L, l > 0L, ),
bor3(vee >= 0L, l > 0L, ))
expect_equal(or3s(vef >= 1L, e > 1L, ),
bor3(vef >= 1L, e > 1L, ))
expect_equal(or3s(veg >= 9L, h > 9L, ),
bor3(veg >= 9L, h > 9L, ))
expect_equal(or3s(veh >= 0L, e > 0L, !logi_k),
bor3(veh >= 0L, e > 0L, !logi_k))
expect_equal(or3s(vei >= 1L, p > 1L, !logi_f),
bor3(vei >= 1L, p > 1L, !logi_f))
expect_equal(or3s(vej >= 9L, g > 9L, !logi_x),
bor3(vej >= 9L, g > 9L, !logi_x))
expect_equal(or3s(vek >= 0L, , ),
bor3(vek >= 0L, , ))
expect_equal(or3s(vel >= 1L, , ),
bor3(vel >= 1L, , ))
expect_equal(or3s(vem >= 9L, , ),
bor3(vem >= 9L, , ))
expect_equal(or3s(ven >= 0L, , n != 0L),
bor3(ven >= 0L, , n != 0L))
expect_equal(or3s(veo >= 1L, , x != 1L),
bor3(veo >= 1L, , x != 1L))
expect_equal(or3s(vep >= 9L, , h != 9L),
bor3(vep >= 9L, , h != 9L))
expect_equal(or3s(veq >= 0L, b > 0L, ),
bor3(veq >= 0L, b > 0L, ))
expect_equal(or3s(ver >= 1L, l > 1L, ),
bor3(ver >= 1L, l > 1L, ))
expect_equal(or3s(ves >= 9L, s > 9L, ),
bor3(ves >= 9L, s > 9L, ))
expect_equal(or3s(vet >= 0L, r > 0L, t != 0L),
bor3(vet >= 0L, r > 0L, t != 0L))
expect_equal(or3s(veu >= 1L, r > 1L, w != 1L),
bor3(veu >= 1L, r > 1L, w != 1L))
expect_equal(or3s(vev >= 9L, t > 9L, e != 9L),
bor3(vev >= 9L, t > 9L, e != 9L))
expect_equal(or3s(vew >= 0L, , ),
bor3(vew >= 0L, , ))
expect_equal(or3s(vex >= 1L, , ),
bor3(vex >= 1L, , ))
expect_equal(or3s(vey >= 9L, , ),
bor3(vey >= 9L, , ))
expect_equal(or3s(vez >= 0L, , m %between% c(-1L, 1L)),
bor3(vez >= 0L, , m %between% c(-1L, 1L)))
expect_equal(or3s(vfa >= 1L, , d %between% c(-1L, 1L)),
bor3(vfa >= 1L, , d %between% c(-1L, 1L)))
expect_equal(or3s(vfb >= 9L, , r %between% c(-1L, 1L)),
bor3(vfb >= 9L, , r %between% c(-1L, 1L)))
expect_equal(or3s(vfc >= 0L, k > 0L, ),
bor3(vfc >= 0L, k > 0L, ))
expect_equal(or3s(vfd >= 1L, p > 1L, ),
bor3(vfd >= 1L, p > 1L, ))
expect_equal(or3s(vfe >= 9L, a > 9L, ),
bor3(vfe >= 9L, a > 9L, ))
expect_equal(or3s(vff >= 0L, z > 0L, x %between% c(-1L, 1L)),
bor3(vff >= 0L, z > 0L, x %between% c(-1L, 1L)))
expect_equal(or3s(vfg >= 1L, q > 1L, c %between% c(-1L, 1L)),
bor3(vfg >= 1L, q > 1L, c %between% c(-1L, 1L)))
expect_equal(or3s(vfh >= 9L, q > 9L, n %between% c(-1L, 1L)),
bor3(vfh >= 9L, q > 9L, n %between% c(-1L, 1L)))
expect_equal(or3s(vfi >= 0L, , ),
bor3(vfi >= 0L, , ))
expect_equal(or3s(vfj >= 1L, , ),
bor3(vfj >= 1L, , ))
expect_equal(or3s(vfk >= 9L, , ),
bor3(vfk >= 9L, , ))
expect_equal(or3s(vfl >= 0L, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vfl >= 0L, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vfm >= 1L, , d %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vfm >= 1L, , d %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vfn >= 9L, , w %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vfn >= 9L, , w %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vfo >= 0L, n > 0L, ),
bor3(vfo >= 0L, n > 0L, ))
expect_equal(or3s(vfp >= 1L, k > 1L, ),
bor3(vfp >= 1L, k > 1L, ))
expect_equal(or3s(vfq >= 9L, i > 9L, ),
bor3(vfq >= 9L, i > 9L, ))
expect_equal(or3s(vfr >= 0L, v > 0L, c %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vfr >= 0L, v > 0L, c %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vfs >= 1L, q > 1L, a %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vfs >= 1L, q > 1L, a %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vft >= 9L, s > 9L, h %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vft >= 9L, s > 9L, h %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vfu >= 0L, , ),
bor3(vfu >= 0L, , ))
expect_equal(or3s(vfv >= 1L, , ),
bor3(vfv >= 1L, , ))
expect_equal(or3s(vfw >= 9L, , ),
bor3(vfw >= 9L, , ))
expect_equal(or3s(vfx >= 0L, , t %in% 1:4),
bor3(vfx >= 0L, , t %in% 1:4))
expect_equal(or3s(vfy >= 1L, , g %in% 1:4),
bor3(vfy >= 1L, , g %in% 1:4))
expect_equal(or3s(vfz >= 9L, , m %in% 1:4),
bor3(vfz >= 9L, , m %in% 1:4))
expect_equal(or3s(vga >= 0L, p > 0L, ),
bor3(vga >= 0L, p > 0L, ))
expect_equal(or3s(vgb >= 1L, t > 1L, ),
bor3(vgb >= 1L, t > 1L, ))
expect_equal(or3s(vgc >= 9L, v > 9L, ),
bor3(vgc >= 9L, v > 9L, ))
expect_equal(or3s(vgd >= 0L, i > 0L, u %in% 1:4),
bor3(vgd >= 0L, i > 0L, u %in% 1:4))
expect_equal(or3s(vge >= 1L, k > 1L, n %in% 1:4),
bor3(vge >= 1L, k > 1L, n %in% 1:4))
expect_equal(or3s(vgf >= 9L, y > 9L, q %in% 1:4),
bor3(vgf >= 9L, y > 9L, q %in% 1:4))
expect_equal(or3s(vgg >= 0L, , ),
bor3(vgg >= 0L, , ))
expect_equal(or3s(vgh >= 1L, , ),
bor3(vgh >= 1L, , ))
expect_equal(or3s(vgi >= 9L, , ),
bor3(vgi >= 9L, , ))
expect_equal(or3s(vgj >= 0L, , v < 0L),
bor3(vgj >= 0L, , v < 0L))
expect_equal(or3s(vgk >= 1L, , f < 1L),
bor3(vgk >= 1L, , f < 1L))
expect_equal(or3s(vgl >= 9L, , j < 9L),
bor3(vgl >= 9L, , j < 9L))
expect_equal(or3s(vgm >= 0L, x > 0L, ),
bor3(vgm >= 0L, x > 0L, ))
expect_equal(or3s(vgn >= 1L, e > 1L, ),
bor3(vgn >= 1L, e > 1L, ))
expect_equal(or3s(vgo >= 9L, e > 9L, ),
bor3(vgo >= 9L, e > 9L, ))
expect_equal(or3s(vgp >= 0L, v > 0L, v < 0L),
bor3(vgp >= 0L, v > 0L, v < 0L))
expect_equal(or3s(vgq >= 1L, z > 1L, v < 1L),
bor3(vgq >= 1L, z > 1L, v < 1L))
expect_equal(or3s(vgr >= 9L, t > 9L, c < 9L),
bor3(vgr >= 9L, t > 9L, c < 9L))
expect_equal(or3s(vgs >= 0L, , ),
bor3(vgs >= 0L, , ))
expect_equal(or3s(vgt >= 1L, , ),
bor3(vgt >= 1L, , ))
expect_equal(or3s(vgu >= 9L, , ),
bor3(vgu >= 9L, , ))
expect_equal(or3s(vgv >= 0L, , v <= 0L),
bor3(vgv >= 0L, , v <= 0L))
expect_equal(or3s(vgw >= 1L, , e <= 1L),
bor3(vgw >= 1L, , e <= 1L))
expect_equal(or3s(vgx >= 9L, , m <= 9L),
bor3(vgx >= 9L, , m <= 9L))
expect_equal(or3s(vgy >= 0L, l > 0L, ),
bor3(vgy >= 0L, l > 0L, ))
expect_equal(or3s(vgz >= 1L, m > 1L, ),
bor3(vgz >= 1L, m > 1L, ))
expect_equal(or3s(vha >= 9L, u > 9L, ),
bor3(vha >= 9L, u > 9L, ))
expect_equal(or3s(vhb >= 0L, v > 0L, k <= 0L),
bor3(vhb >= 0L, v > 0L, k <= 0L))
expect_equal(or3s(vhc >= 1L, q > 1L, h <= 1L),
bor3(vhc >= 1L, q > 1L, h <= 1L))
expect_equal(or3s(vhd >= 9L, y > 9L, i <= 9L),
bor3(vhd >= 9L, y > 9L, i <= 9L))
expect_equal(or3s(vhe >= 0L, , ),
bor3(vhe >= 0L, , ))
expect_equal(or3s(vhf >= 1L, , ),
bor3(vhf >= 1L, , ))
expect_equal(or3s(vhg >= 9L, , ),
bor3(vhg >= 9L, , ))
expect_equal(or3s(vhh >= 0L, , s == 0L),
bor3(vhh >= 0L, , s == 0L))
expect_equal(or3s(vhi >= 1L, , q == 1L),
bor3(vhi >= 1L, , q == 1L))
expect_equal(or3s(vhj >= 9L, , n == 9L),
bor3(vhj >= 9L, , n == 9L))
expect_equal(or3s(vhk >= 0L, s > 0L, ),
bor3(vhk >= 0L, s > 0L, ))
expect_equal(or3s(vhl >= 1L, e > 1L, ),
bor3(vhl >= 1L, e > 1L, ))
expect_equal(or3s(vhm >= 9L, u > 9L, ),
bor3(vhm >= 9L, u > 9L, ))
expect_equal(or3s(vhn >= 0L, q > 0L, q == 0L),
bor3(vhn >= 0L, q > 0L, q == 0L))
expect_equal(or3s(vho >= 1L, t > 1L, d == 1L),
bor3(vho >= 1L, t > 1L, d == 1L))
expect_equal(or3s(vhp >= 9L, t > 9L, m == 9L),
bor3(vhp >= 9L, t > 9L, m == 9L))
expect_equal(or3s(vhq >= 0L, , ),
bor3(vhq >= 0L, , ))
expect_equal(or3s(vhr >= 1L, , ),
bor3(vhr >= 1L, , ))
expect_equal(or3s(vhs >= 9L, , ),
bor3(vhs >= 9L, , ))
expect_equal(or3s(vht >= 0L, , v > 0L),
bor3(vht >= 0L, , v > 0L))
expect_equal(or3s(vhu >= 1L, , r > 1L),
bor3(vhu >= 1L, , r > 1L))
expect_equal(or3s(vhv >= 9L, , v > 9L),
bor3(vhv >= 9L, , v > 9L))
expect_equal(or3s(vhw >= 0L, g > 0L, ),
bor3(vhw >= 0L, g > 0L, ))
expect_equal(or3s(vhx >= 1L, g > 1L, ),
bor3(vhx >= 1L, g > 1L, ))
expect_equal(or3s(vhy >= 9L, n > 9L, ),
bor3(vhy >= 9L, n > 9L, ))
expect_equal(or3s(vhz >= 0L, v > 0L, p > 0L),
bor3(vhz >= 0L, v > 0L, p > 0L))
expect_equal(or3s(via >= 1L, p > 1L, r > 1L),
bor3(via >= 1L, p > 1L, r > 1L))
expect_equal(or3s(vib >= 9L, d > 9L, p > 9L),
bor3(vib >= 9L, d > 9L, p > 9L))
expect_equal(or3s(vic >= 0L, , ),
bor3(vic >= 0L, , ))
expect_equal(or3s(vid >= 1L, , ),
bor3(vid >= 1L, , ))
expect_equal(or3s(vie >= 9L, , ),
bor3(vie >= 9L, , ))
expect_equal(or3s(vif >= 0L, , m >= 0L),
bor3(vif >= 0L, , m >= 0L))
expect_equal(or3s(vig >= 1L, , a >= 1L),
bor3(vig >= 1L, , a >= 1L))
expect_equal(or3s(vih >= 9L, , n >= 9L),
bor3(vih >= 9L, , n >= 9L))
expect_equal(or3s(vii >= 0L, h > 0L, ),
bor3(vii >= 0L, h > 0L, ))
expect_equal(or3s(vij >= 1L, n > 1L, ),
bor3(vij >= 1L, n > 1L, ))
expect_equal(or3s(vik >= 9L, o > 9L, ),
bor3(vik >= 9L, o > 9L, ))
expect_equal(or3s(vil >= 0L, r > 0L, x >= 0L),
bor3(vil >= 0L, r > 0L, x >= 0L))
expect_equal(or3s(vim >= 1L, p > 1L, w >= 1L),
bor3(vim >= 1L, p > 1L, w >= 1L))
expect_equal(or3s(vin >= 9L, u > 9L, g >= 9L),
bor3(vin >= 9L, u > 9L, g >= 9L))
expect_equal(or3s(vio >= 0L, , ),
bor3(vio >= 0L, , ))
expect_equal(or3s(vip >= 1L, , ),
bor3(vip >= 1L, , ))
expect_equal(or3s(viq >= 9L, , ),
bor3(viq >= 9L, , ))
expect_equal(or3s(vir >= 0L, , logi_m),
bor3(vir >= 0L, , logi_m))
expect_equal(or3s(vis >= 1L, , logi_c),
bor3(vis >= 1L, , logi_c))
expect_equal(or3s(vit >= 9L, , logi_w),
bor3(vit >= 9L, , logi_w))
expect_equal(or3s(viu >= 0L, e >= 0L, ),
bor3(viu >= 0L, e >= 0L, ))
expect_equal(or3s(viv >= 1L, z >= 1L, ),
bor3(viv >= 1L, z >= 1L, ))
expect_equal(or3s(viw >= 9L, z >= 9L, ),
bor3(viw >= 9L, z >= 9L, ))
expect_equal(or3s(vix >= 0L, g >= 0L, logi_f),
bor3(vix >= 0L, g >= 0L, logi_f))
expect_equal(or3s(viy >= 1L, d >= 1L, logi_g),
bor3(viy >= 1L, d >= 1L, logi_g))
expect_equal(or3s(viz >= 9L, w >= 9L, logi_e),
bor3(viz >= 9L, w >= 9L, logi_e))
expect_equal(or3s(vja >= 0L, , ),
bor3(vja >= 0L, , ))
expect_equal(or3s(vjb >= 1L, , ),
bor3(vjb >= 1L, , ))
expect_equal(or3s(vjc >= 9L, , ),
bor3(vjc >= 9L, , ))
expect_equal(or3s(vjd >= 0L, , !logi_n),
bor3(vjd >= 0L, , !logi_n))
expect_equal(or3s(vje >= 1L, , !logi_p),
bor3(vje >= 1L, , !logi_p))
expect_equal(or3s(vjf >= 9L, , !logi_b),
bor3(vjf >= 9L, , !logi_b))
expect_equal(or3s(vjg >= 0L, f >= 0L, ),
bor3(vjg >= 0L, f >= 0L, ))
expect_equal(or3s(vjh >= 1L, z >= 1L, ),
bor3(vjh >= 1L, z >= 1L, ))
expect_equal(or3s(vji >= 9L, m >= 9L, ),
bor3(vji >= 9L, m >= 9L, ))
expect_equal(or3s(vjj >= 0L, j >= 0L, !logi_p),
bor3(vjj >= 0L, j >= 0L, !logi_p))
expect_equal(or3s(vjk >= 1L, p >= 1L, !logi_z),
bor3(vjk >= 1L, p >= 1L, !logi_z))
expect_equal(or3s(vjl >= 9L, g >= 9L, !logi_j),
bor3(vjl >= 9L, g >= 9L, !logi_j))
expect_equal(or3s(vjm >= 0L, , ),
bor3(vjm >= 0L, , ))
expect_equal(or3s(vjn >= 1L, , ),
bor3(vjn >= 1L, , ))
expect_equal(or3s(vjo >= 9L, , ),
bor3(vjo >= 9L, , ))
expect_equal(or3s(vjp >= 0L, , a != 0L),
bor3(vjp >= 0L, , a != 0L))
expect_equal(or3s(vjq >= 1L, , k != 1L),
bor3(vjq >= 1L, , k != 1L))
expect_equal(or3s(vjr >= 9L, , q != 9L),
bor3(vjr >= 9L, , q != 9L))
expect_equal(or3s(vjs >= 0L, c >= 0L, ),
bor3(vjs >= 0L, c >= 0L, ))
expect_equal(or3s(vjt >= 1L, l >= 1L, ),
bor3(vjt >= 1L, l >= 1L, ))
expect_equal(or3s(vju >= 9L, c >= 9L, ),
bor3(vju >= 9L, c >= 9L, ))
expect_equal(or3s(vjv >= 0L, m >= 0L, n != 0L),
bor3(vjv >= 0L, m >= 0L, n != 0L))
expect_equal(or3s(vjw >= 1L, y >= 1L, i != 1L),
bor3(vjw >= 1L, y >= 1L, i != 1L))
expect_equal(or3s(vjx >= 9L, z >= 9L, e != 9L),
bor3(vjx >= 9L, z >= 9L, e != 9L))
expect_equal(or3s(vjy >= 0L, , ),
bor3(vjy >= 0L, , ))
expect_equal(or3s(vjz >= 1L, , ),
bor3(vjz >= 1L, , ))
expect_equal(or3s(vka >= 9L, , ),
bor3(vka >= 9L, , ))
expect_equal(or3s(vkb >= 0L, , s %between% c(-1L, 1L)),
bor3(vkb >= 0L, , s %between% c(-1L, 1L)))
expect_equal(or3s(vkc >= 1L, , y %between% c(-1L, 1L)),
bor3(vkc >= 1L, , y %between% c(-1L, 1L)))
expect_equal(or3s(vkd >= 9L, , h %between% c(-1L, 1L)),
bor3(vkd >= 9L, , h %between% c(-1L, 1L)))
expect_equal(or3s(vke >= 0L, x >= 0L, ),
bor3(vke >= 0L, x >= 0L, ))
expect_equal(or3s(vkf >= 1L, r >= 1L, ),
bor3(vkf >= 1L, r >= 1L, ))
expect_equal(or3s(vkg >= 9L, r >= 9L, ),
bor3(vkg >= 9L, r >= 9L, ))
expect_equal(or3s(vkh >= 0L, x >= 0L, c %between% c(-1L, 1L)),
bor3(vkh >= 0L, x >= 0L, c %between% c(-1L, 1L)))
expect_equal(or3s(vki >= 1L, v >= 1L, y %between% c(-1L, 1L)),
bor3(vki >= 1L, v >= 1L, y %between% c(-1L, 1L)))
expect_equal(or3s(vkj >= 9L, l >= 9L, b %between% c(-1L, 1L)),
bor3(vkj >= 9L, l >= 9L, b %between% c(-1L, 1L)))
expect_equal(or3s(vkk >= 0L, , ),
bor3(vkk >= 0L, , ))
expect_equal(or3s(vkl >= 1L, , ),
bor3(vkl >= 1L, , ))
expect_equal(or3s(vkm >= 9L, , ),
bor3(vkm >= 9L, , ))
expect_equal(or3s(vkn >= 0L, , n %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vkn >= 0L, , n %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vko >= 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vko >= 1L, , t %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vkp >= 9L, , s %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vkp >= 9L, , s %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vkq >= 0L, t >= 0L, ),
bor3(vkq >= 0L, t >= 0L, ))
expect_equal(or3s(vkr >= 1L, p >= 1L, ),
bor3(vkr >= 1L, p >= 1L, ))
expect_equal(or3s(vks >= 9L, t >= 9L, ),
bor3(vks >= 9L, t >= 9L, ))
expect_equal(or3s(vkt >= 0L, c >= 0L, i %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vkt >= 0L, c >= 0L, i %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vku >= 1L, z >= 1L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vku >= 1L, z >= 1L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vkv >= 9L, a >= 9L, y %in% c(4L, -3L, 2L, 7L, 8L)),
bor3(vkv >= 9L, a >= 9L, y %in% c(4L, -3L, 2L, 7L, 8L)))
expect_equal(or3s(vkw >= 0L, , ),
bor3(vkw >= 0L, , ))
expect_equal(or3s(vkx >= 1L, , ),
bor3(vkx >= 1L, , ))
expect_equal(or3s(vky >= 9L, , ),
bor3(vky >= 9L, , ))
expect_equal(or3s(vkz >= 0L, , m %in% 1:4),
bor3(vkz >= 0L, , m %in% 1:4))
expect_equal(or3s(vla >= 1L, , g %in% 1:4),
bor3(vla >= 1L, , g %in% 1:4))
expect_equal(or3s(vlb >= 9L, , b %in% 1:4),
bor3(vlb >= 9L, , b %in% 1:4))
expect_equal(or3s(vlc >= 0L, p >= 0L, ),
bor3(vlc >= 0L, p >= 0L, ))
expect_equal(or3s(vld >= 1L, i >= 1L, ),
bor3(vld >= 1L, i >= 1L, ))
expect_equal(or3s(vle >= 9L, q >= 9L, ),
bor3(vle >= 9L, q >= 9L, ))
expect_equal(or3s(vlf >= 0L, b >= 0L, w %in% 1:4),
bor3(vlf >= 0L, b >= 0L, w %in% 1:4))
expect_equal(or3s(vlg >= 1L, o >= 1L, x %in% 1:4),
bor3(vlg >= 1L, o >= 1L, x %in% 1:4))
expect_equal(or3s(vlh >= 9L, r >= 9L, x %in% 1:4),
bor3(vlh >= 9L, r >= 9L, x %in% 1:4))
expect_equal(or3s(vli >= 0L, , ),
bor3(vli >= 0L, , ))
expect_equal(or3s(vlj >= 1L, , ),
bor3(vlj >= 1L, , ))
expect_equal(or3s(vlk >= 9L, , ),
bor3(vlk >= 9L, , ))
expect_equal(or3s(vll >= 0L, , l < 0L),
bor3(vll >= 0L, , l < 0L))
expect_equal(or3s(vlm >= 1L, , t < 1L),
bor3(vlm >= 1L, , t < 1L))
expect_equal(or3s(vln >= 9L, , y < 9L),
bor3(vln >= 9L, , y < 9L))
expect_equal(or3s(vlo >= 0L, o >= 0L, ),
bor3(vlo >= 0L, o >= 0L, ))
expect_equal(or3s(vlp >= 1L, y >= 1L, ),
bor3(vlp >= 1L, y >= 1L, ))
expect_equal(or3s(vlq >= 9L, y >= 9L, ),
bor3(vlq >= 9L, y >= 9L, ))
expect_equal(or3s(vlr >= 0L, d >= 0L, a < 0L),
bor3(vlr >= 0L, d >= 0L, a < 0L))
expect_equal(or3s(vls >= 1L, m >= 1L, z < 1L),
bor3(vls >= 1L, m >= 1L, z < 1L))
expect_equal(or3s(vlt >= 9L, p >= 9L, j < 9L),
bor3(vlt >= 9L, p >= 9L, j < 9L))
expect_equal(or3s(vlu >= 0L, , ),
bor3(vlu >= 0L, , ))
expect_equal(or3s(vlv >= 1L, , ),
bor3(vlv >= 1L, , ))
expect_equal(or3s(vlw >= 9L, , ),
bor3(vlw >= 9L, , ))
expect_equal(or3s(vlx >= 0L, , p <= 0L),
bor3(vlx >= 0L, , p <= 0L))
expect_equal(or3s(vly >= 1L, , w <= 1L),
bor3(vly >= 1L, , w <= 1L))
expect_equal(or3s(vlz >= 9L, , a <= 9L),
bor3(vlz >= 9L, , a <= 9L))
expect_equal(or3s(vma >= 0L, w >= 0L, ),
bor3(vma >= 0L, w >= 0L, ))
expect_equal(or3s(vmb >= 1L, f >= 1L, ),
bor3(vmb >= 1L, f >= 1L, ))
expect_equal(or3s(vmc >= 9L, v >= 9L, ),
bor3(vmc >= 9L, v >= 9L, ))
expect_equal(or3s(vmd >= 0L, f >= 0L, c <= 0L),
bor3(vmd >= 0L, f >= 0L, c <= 0L))
expect_equal(or3s(vme >= 1L, r >= 1L, z <= 1L),
bor3(vme >= 1L, r >= 1L, z <= 1L))
expect_equal(or3s(vmf >= 9L, w >= 9L, b <= 9L),
bor3(vmf >= 9L, w >= 9L, b <= 9L))
expect_equal(or3s(vmg >= 0L, , ),
bor3(vmg >= 0L, , ))
expect_equal(or3s(vmh >= 1L, , ),
bor3(vmh >= 1L, , ))
expect_equal(or3s(vmi >= 9L, , ),
bor3(vmi >= 9L, , ))
expect_equal(or3s(vmj >= 0L, , a == 0L),
bor3(vmj >= 0L, , a == 0L))
expect_equal(or3s(vmk >= 1L, , s == 1L),
bor3(vmk >= 1L, , s == 1L))
expect_equal(or3s(vml >= 9L, , u == 9L),
bor3(vml >= 9L, , u == 9L))
expect_equal(or3s(vmm >= 0L, q >= 0L, ),
bor3(vmm >= 0L, q >= 0L, ))
expect_equal(or3s(vmn >= 1L, t >= 1L, ),
bor3(vmn >= 1L, t >= 1L, ))
expect_equal(or3s(vmo >= 9L, y >= 9L, ),
bor3(vmo >= 9L, y >= 9L, ))
expect_equal(or3s(vmp >= 0L, t >= 0L, r == 0L),
bor3(vmp >= 0L, t >= 0L, r == 0L))
expect_equal(or3s(vmq >= 1L, b >= 1L, f == 1L),
bor3(vmq >= 1L, b >= 1L, f == 1L))
expect_equal(or3s(vmr >= 9L, d >= 9L, v == 9L),
bor3(vmr >= 9L, d >= 9L, v == 9L))
expect_equal(or3s(vms >= 0L, , ),
bor3(vms >= 0L, , ))
expect_equal(or3s(vmt >= 1L, , ),
bor3(vmt >= 1L, , ))
expect_equal(or3s(vmu >= 9L, , ),
bor3(vmu >= 9L, , ))
expect_equal(or3s(vmv >= 0L, , t > 0L),
bor3(vmv >= 0L, , t > 0L))
expect_equal(or3s(vmw >= 1L, , f > 1L),
bor3(vmw >= 1L, , f > 1L))
expect_equal(or3s(vmx >= 9L, , f > 9L),
bor3(vmx >= 9L, , f > 9L))
expect_equal(or3s(vmy >= 0L, q >= 0L, ),
bor3(vmy >= 0L, q >= 0L, ))
expect_equal(or3s(vmz >= 1L, h >= 1L, ),
bor3(vmz >= 1L, h >= 1L, ))
expect_equal(or3s(vna >= 9L, g >= 9L, ),
bor3(vna >= 9L, g >= 9L, ))
expect_equal(or3s(vnb >= 0L, l >= 0L, r > 0L),
bor3(vnb >= 0L, l >= 0L, r > 0L))
expect_equal(or3s(vnc >= 1L, w >= 1L, z > 1L),
bor3(vnc >= 1L, w >= 1L, z > 1L))
expect_equal(or3s(vnd >= 9L, d >= 9L, m > 9L),
bor3(vnd >= 9L, d >= 9L, m > 9L))
expect_equal(or3s(vne >= 0L, , ),
bor3(vne >= 0L, , ))
expect_equal(or3s(vnf >= 1L, , ),
bor3(vnf >= 1L, , ))
expect_equal(or3s(vng >= 9L, , ),
bor3(vng >= 9L, , ))
expect_equal(or3s(vnh >= 0L, , k >= 0L),
bor3(vnh >= 0L, , k >= 0L))
expect_equal(or3s(vni >= 1L, , z >= 1L),
bor3(vni >= 1L, , z >= 1L))
expect_equal(or3s(vnj >= 9L, , v >= 9L),
bor3(vnj >= 9L, , v >= 9L))
expect_equal(or3s(vnk >= 0L, x >= 0L, ),
bor3(vnk >= 0L, x >= 0L, ))
expect_equal(or3s(vnl >= 1L, n >= 1L, ),
bor3(vnl >= 1L, n >= 1L, ))
expect_equal(or3s(vnm >= 9L, r >= 9L, ),
bor3(vnm >= 9L, r >= 9L, ))
expect_equal(or3s(vnn >= 0L, y >= 0L, o >= 0L),
bor3(vnn >= 0L, y >= 0L, o >= 0L))
expect_equal(or3s(vno >= 1L, y >= 1L, t >= 1L),
bor3(vno >= 1L, y >= 1L, t >= 1L))
expect_equal(or3s(vnp >= 9L, d >= 9L, v >= 9L),
bor3(vnp >= 9L, d >= 9L, v >= 9L))
x <- integer(0)
y <- integer(0)
exprA <- c(1:10)
exprB <- 1:10 + 5L
exprC <- 1:10 + 1L
or <- `|`
or3 <- function(i, j, k) i | j | k
sexprA <- 10L
expect_equal(or3s(exprA >= 1L, exprB >= 1L, exprC >= 1L,
exprA <= 6L, exprB <= 7L, exprC <= sexprA),
or(or3(exprA >= 1L, exprB >= 1L, exprC >= 1L),
or3(exprA <= 6L, exprB <= 7L, exprC <= 10L)))
expect_equal(or3s(exprA >= 1L, exprB >= 1L, exprC >= 1L,
exprA <= 6L, exprB <= 7L, exprC <= sexprA,
exprA <= 6L, exprB <= 7L, exprC <= sexprA),
or(or3(exprA >= 1L, exprB >= 1L, exprC >= 1L),
or3(exprA <= 6L, exprB <= 7L, exprC <= 10L)))
library(data.table)
DT <- CJ(u = logical(4),
v = c(FALSE, FALSE, FALSE, TRUE),
w = c(FALSE, FALSE, TRUE, TRUE),
x = c(FALSE, TRUE, TRUE, TRUE),
y = c(TRUE, TRUE, TRUE, TRUE))
DT[, ans1 := or3s(u, v, w, x, !y)]
DT[, bns1 := u | v | w | x | !y]
DT[, ans2 := or3s(u, v, w, !x, y)]
DT[, bns2 := u | v | w | !x | y]
DT[, ans3 := or3s(u, v, w, !x, !y)]
DT[, bns3 := u | v | w | !x | !y]
expect_equal(DT$ans1, DT$bns1)
expect_equal(DT$ans2, DT$bns2)
expect_equal(DT$ans3, DT$bns3) |
"mariokart" |
summary.bootDominanceAnalysis<-function(object,fit.functions=NULL,...) {
out<-list()
mm.n<-nrow(object$m.names)
m.out<-list()
ii<-1
if(is.null(fit.functions)) {
fit.functions=object$fit.functions
}
m.names<-object$m.names
m.names[,1]<-replaceTermsInString(string = m.names[,1], object$terms)
m.names[,2]<-replaceTermsInString(string = m.names[,2], object$terms)
for(an in c("complete","conditional","general")) {
for(ff in fit.functions) {
for(m in 1:mm.n) {
boot.t<-object$boot$t[,ii]
m.out[[ii]]<-list(f=ff, dominance=an, i=m.names[m,1], k=m.names[m,2],
Dij=object$boot$t0[ii], mDij=mean(boot.t), `SE.Dij`=sd(boot.t),
Pij=sum(boot.t==1)/object$R, Pji=sum(boot.t==0)/object$R,
Pnoij=sum(boot.t==0.5) / object$R,
Rep=sum(boot.t==object$boot$t0[ii]) / object$R )
ii<-ii+1
}
}
}
mm.out<-data.frame(do.call(rbind,m.out))
for(ff in fit.functions) {
out[[ff]]<-data.frame(lapply(mm.out[mm.out[,1]==ff,-1],unlist))
}
class(out)<-"summary.bootDominanceAnalysis"
out
}
print.summary.bootDominanceAnalysis<-function(x,round.digits=3,...) {
cat("Dominance Analysis\n")
cat("==================\n")
for(i in names(x)) {
cat("Fit index:",i,"\n")
out<-x[[i]]
print(format(out,digits=round.digits),row.names=F,...)
cat("\n")
}
} |
samplesize <- 1.e6
nbins <- as.integer(sqrt(samplesize))
breaks <- (0:nbins)/nbins
alpha <- 1.e-3
set.seed(123456)
library(Runuran)
is.error <- function (expr) { is(try(expr), "try-error") }
unr <- new("unuran", "normal()")
unr
print(unr)
unuran.details(unr)
unuran.details(unr,show=TRUE,return.list=FALSE)
unuran.details(unr,show=TRUE,return.list=TRUE)
unuran.details(unr,show=FALSE,return.list=TRUE)
print(unuran.details(unr,show=FALSE,return.list=TRUE))
unuran.details(unr,show=FALSE,return.list=FALSE)
print(unuran.details(unr,show=FALSE,return.list=FALSE))
unuran.is.inversion(unr)
unuran.sample(unr)
unuran.sample(unr,10)
x <- unuran.sample(unr, samplesize)
ur(unr)
ur(unr,10)
chisq.test( hist(pnorm(x),plot=FALSE,breaks=breaks)$density )
unr <- unuran.new("normal()")
unuran.sample(unr)
unuran.sample(unr,10)
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pnorm(x),plot=FALSE,breaks=breaks)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
unr <- new("unuran", "normal()", "pinv")
unr
print(unr)
unuran.details(unr)
print(unuran.details(unr,show=FALSE,return.list=TRUE))
print(unuran.details(unr,show=FALSE,debug=TRUE))
unuran.is.inversion(unr)
rm(unr)
gausspdf <- function (x) { exp(-0.5*x^2) }
gaussdpdf <- function (x) { -x*exp(-0.5*x^2) }
gauss <- new("unuran.cont", pdf=gausspdf, dpdf=gaussdpdf, lb=-Inf, ub=Inf, center=0.1)
unr <- 0; unr <- unuran.new(gauss, "tdr")
unr
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pnorm(x),plot=FALSE,breaks=breaks)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
gausspdf <- function (x) { exp(-0.5*x^2) }
gaussdpdf <- function (x) { -x*exp(-0.5*x^2) }
gauss <- unuran.cont.new(pdf=gausspdf, dpdf=gaussdpdf, lb=-Inf, ub=Inf, center=0.1)
unr <- unuran.new(gauss, "tdr")
unr
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pnorm(x),plot=FALSE,breaks=breaks)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
gausspdf <- function (x) { -0.5*x^2 }
gaussdpdf <- function (x) { -x }
gauss <- new("unuran.cont", pdf=gausspdf, dpdf=gaussdpdf, islog=TRUE, lb=-Inf, ub=Inf, mode=0)
unr <- unuran.new(gauss, "tdr")
unr
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pnorm(x),plot=FALSE,breaks=breaks)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
gausspdf <- function (x) { -0.5*x^2 }
gaussdpdf <- function (x) { -x }
gauss <- new("unuran.cont", pdf=gausspdf, dpdf=gaussdpdf, islog=TRUE, lb=-Inf, ub=Inf)
unr <- unuran.new(gauss, "ars")
unr
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pnorm(x),plot=FALSE,breaks=breaks)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
unr <- new("unuran", "binomial(20,0.5)", "dgt")
unuran.sample(unr)
unuran.sample(unr,10)
x <- unuran.sample(unr, samplesize)
rm(unr)
pv <- dbinom(0:100,100,0.3)
binom <- new("unuran.discr",pv=pv,lb=0)
unr <- unuran.new(binom, "dgt")
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pbinom(x,100,0.3),plot=FALSE)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
pmf <- function(x) dbinom(x,100,0.3)
binom <- new("unuran.discr",pmf=pmf,lb=0,ub=100)
unr <- unuran.new(binom, "dgt")
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pbinom(x,100,0.3),plot=FALSE)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
pmf <- function(x) dbinom(x,100,0.3)
binom <- new("unuran.discr",pmf=pmf,lb=0,ub=100)
unr <- unuran.new(binom, "dari")
x <- unuran.sample(unr, samplesize)
pval <- chisq.test( hist(pbinom(x,100,0.3),plot=FALSE)$density )$p.value
if (pval < alpha) stop("chisq test FAILED! p-value=",signif(pval))
rm(unr)
mvpdf <- function (x) { exp(-sum(x^2)) }
mvd <- new("unuran.cmv", dim=2, pdf=mvpdf, mode=c(0,0))
unr <- unuran.new(mvd, "hitro")
x <- unuran.sample(unr, 10)
x
rm(unr)
unr <- unuran.new(mvd, "vnrou")
x <- unuran.sample(unr, 10)
x
rm(unr)
unr <- unuran.new("normal()","hinv; u_resolution=1.e-13")
Tmax <- 0
for (U in (0:20)/20) {
T <- pnorm( uq(unr,U) ) - U
print (T)
Tmax <- max(abs(T),Tmax)
}
cat("Max. error =",Tmax,"\n")
if (Tmax > 1.e-13) stop ("Max. error exceeds limit")
U <- (0:20)/20
T <- pnorm( uq(unr,U) ) - U
print (T)
Tmax <- max(abs(T))
cat("Max. error =",Tmax,"\n")
if (Tmax > 1.e-13) stop ("Max. error exceeds limit")
for (U in c(-1,-0.001,0,0.5,1.,1.001,NA,NaN) ) {
cat ("U =",U,"\tX =",uq(unr,U),"\n")
}
U <- c(-1,-0.001,0,0.5,1.,1.001,NA,NaN)
T <- uq(unr,U)
rbind(U,T)
uq(unr,numeric())
rm(unr)
unr <- unuran.new("normal()","tdr")
if( ! is.error( uq(unr,0.5) ) )
stop("'uq' does not detect UNU.RAN object with non-inversion method")
if( ! is.error( uq(1,0.5) ) )
stop("'uq' does not detect invalid argument 'unr'")
if( ! is.error( uq(unr,"a") ) )
stop("'uq' does not detect invalid argument 'U'")
rm(unr)
distr <- unuran.cont.new(pdf=function(x){exp(-x)}, lb=0,ub=Inf)
x <- rexp(100)
e <- max(abs(ud(distr, x) - dexp(x)))
e; if (e>1.e-10) stop("error too large")
distr <- unuran.cont.new(pdf=function(x){-x}, islog=TRUE, lb=0,ub=Inf)
x <- rexp(100)
e <- max(abs(ud(distr, x, islog=TRUE) + x))
e; if (e>1.e-10) stop("error too large")
distr <- udgeom(prob=0.8)
x <- rgeom(100, prob=0.8)
e <- max(abs(ud(distr,x) - dgeom(x,prob=0.8)))
e; if (e>1.e-10) stop("error too large")
rm(distr,x,e)
unr <- pinv.new(pdf=function(x){exp(-x)}, lb=0,ub=Inf)
x <- rexp(100)
e <- max(abs(ud(unr, x) - dexp(x)))
e; if (e>1.e-10) stop("error too large")
unr <- pinv.new(pdf=function(x){-x}, islog=TRUE, lb=0,ub=Inf)
x <- rexp(100)
e <- max(abs(ud(unr, x, islog=TRUE) +x))
e; if (e>1.e-10) stop("error too large")
unr <- darid.new(udgeom(prob=0.8))
x <- rgeom(100, prob=0.8)
e <- max(abs(ud(unr,x) - dgeom(x,prob=0.8)))
e; if (e>1.e-10) stop("error too large")
rm(unr,x,e)
distr <- unuran.cont.new(lb=0,ub=1)
if (!all(is.na(ud(distr,1))))
stop("'ud' ignores missing PDF")
distr <- unuran.discr.new(lb=0,ub=1)
if (!all(is.na(ud(distr,1))))
stop("'ud' ignores missing PMF")
unr <- pinv.new(cdf=pexp,lb=0,ub=Inf)
if (!all(is.na(ud(distr,1))))
stop("'ud' ignores missing PDF")
unr <- pinv.new(pdf=dexp,lb=0,ub=Inf)
unuran.packed(unr) <- TRUE
if( ! is.error( ud(unr, 1) ) )
stop("'ud' does not detect packed generator object")
rm(distr,unr)
distr <- unuran.cont.new(cdf=function(x){1-exp(-x)}, lb=0,ub=Inf)
x <- rexp(100)
e <- max(abs(up(distr, x) - pexp(x)))
e; if (e>1.e-10) stop("error too large")
distr <- udgeom(prob=0.8)
x <- rgeom(100, prob=0.8)
e <- max(abs(up(distr,x) - pgeom(x,prob=0.8)))
e; if (e>1.e-10) stop("error too large")
unr <- pinv.new(pdf=function(x){exp(5-x)}, lb=0,ub=Inf)
x <- rexp(100)
e <- max(abs(up(unr, x) - pexp(x)))
e; if (e>1.e-10) stop("error too large")
rm(distr,unr,x,e)
distr <- unuran.cont.new(lb=0,ub=1)
if( ! is.error( up(distr,1) ) )
stop("'up' ignores missing CDF")
distr <- unuran.discr.new(lb=0,ub=1)
if( ! is.error( up(distr,1) ) )
stop("'up' ignores missing CDF")
unr <- tdr.new(pdf=dexp,lb=0,ub=Inf)
if( ! is.error( up(unr,1) ) )
stop("'up' ignores invalid method PINV")
unr <- pinv.new(pdf=dexp,lb=0,ub=Inf)
unuran.packed(unr) <- TRUE
if( ! is.error( up(unr, 1) ) )
stop("'up' does not detect packed generator object")
rm(distr,unr)
unr <- pinv.new(dnorm,lb=0,ub=Inf)
unuran.packed(unr) <- TRUE
unr
unuran.details(unr)
unuran.details(unr,show=TRUE,return.list=TRUE)
unuran.details(unr,show=FALSE,return.list=TRUE)
print(unuran.details(unr,show=FALSE,return.list=TRUE))
print(unuran.details(unr,show=FALSE,debug=TRUE))
unuran.details(unr,show=FALSE,return.list=FALSE)
rm(unr)
unr <- pinv.new(dnorm,lb=0,ub=Inf)
unuran.packed(unr) <- FALSE
unuran.packed(unr) <- TRUE
if( ! is.error( unuran.packed(unr) <- FALSE ) )
stop("'unuran.packed' tries to unpack UNU.RAN objects")
unuran.packed(unr) <- TRUE
rm(unr)
unr <- tdr.new(dnorm,lb=0,ub=Inf)
if( ! is.error( unuran.packed(unr) <- TRUE ) )
stop("'unuran.packed' does not detect non-packable UNU.RAN objects")
rm(unr)
comp <- c(unuran.new("normal"),unuran.new("cauchy"),unuran.new("exponential"))
prob <- c(1,2,3)
unr <- mixt.new(prob,comp)
x <- unuran.sample(unr, 10)
x
rm(unr)
comp <- c(pinvd.new(udnorm(lb=-Inf,ub=-1)),
pinvd.new(udcauchy(lb=-1,ub=1)),
pinvd.new(udexp(lb=1,ub=Inf)) )
prob <- c(1,2,3)
unr <- mixt.new(prob,comp,inversion=TRUE)
x <- unuran.sample(unr, 10)
x
rm(unr)
unr <- tdrd.new(udnorm())
unuran.verify.hat(unr)
rm(unr)
unr <- tdrd.new(udnorm())
unuran.verify.hat(unr,show=FALSE)
rm(unr)
pdf <- function(x) { -x - 0.999*log(x) }
dpdf <- function(x) { -1 - 0.999/x }
distr <- unuran.cont.new(pdf=pdf, dpdf=dpdf, islog=TRUE, lb=0, ub=0.5, mode=0)
unr <- unuran.new(distr,method="itdr;cp=-0.999")
unuran.verify.hat(unr)
rm(unr); rm(distr); rm(pdf); rm(dpdf)
unr <- unuran.new(udnorm(),method="nrou;v=0.6")
failed <- unuran.verify.hat(unr)
failed
rm(unr); rm (failed)
unr <- pinvd.new(udnorm())
if (! is.error( unuran.verify.hat(unr) ) )
stop("method must throw error for inversion method")
rm(unr)
detach("package:Runuran",unload = TRUE) |
cov2.2013CLX <- function(X, Y){
check_nd(X)
check_nd(Y)
if (ncol(X)!=ncol(Y)){
stop("* cov2.2013CLX : two samples X and Y should be of same dimension.")
}
n1 = nrow(X)
n2 = nrow(Y)
p = ncol(X)
Sigma1.hat = cov(X)*(n1-1)/n1
Sigma2.hat = cov(Y)*(n2-1)/n2
bar.X = colMeans(X)
theta1.hat = matrix(0, nrow=p, ncol=p)
for(i in 1:p){
for(j in 1:p){
theta1.hat[i,j] = sum( ((X[,i]-bar.X[i])*(X[,j]-bar.X[j]) - Sigma1.hat[i,j])^2 )/n1
}
}
bar.Y = colMeans(Y)
theta2.hat = matrix(0, nrow=p, ncol=p)
for(i in 1:p){
for(j in 1:p){
theta2.hat[i,j] = sum( ((Y[,i]-bar.Y[i])*(Y[,j]-bar.Y[j]) - Sigma2.hat[i,j])^2 )/n2
}
}
M.mat = (Sigma1.hat - Sigma2.hat)^2 / (theta1.hat/n1 + theta2.hat/n2)
Mn = max(M.mat)
pval.num = Mn - 4*log(p) + log(log(p))
pvalue = 1-exp(-(1/sqrt(8*pi))*exp(-pval.num/2))
hname = "Two-sample Test for Covariance Matrices by Cai, Liu, and Xia (2013)"
Ha = "two covariances are not equal."
thestat = Mn
DNAME = paste(deparse(substitute(X))," and ",deparse(substitute(Y)),sep="")
names(thestat) = "statistic"
res = list(statistic=thestat, p.value=pvalue, alternative = Ha, method=hname, data.name = DNAME)
class(res) = "htest"
return(res)
} |
knitr::opts_chunk$set(
comment = "
)
library(flair)
library(dplyr)
library(ggplot2)
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate('
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
') %>%
flair("%>%")
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate("how_to_pipe") %>%
flair("%>%")
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate("how_to_pipe") %>%
flair_funs()
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate("how_to_pipe") %>%
flair_input_vals()
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate('
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
') %>%
flair("%>%")
mean(not_an_object)
decorate('mean(not_an_object)',
error = TRUE) %>%
flair("not_an_object")
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate('how_to_pipe') %>%
flair("%>%") %>%
flair("Sepal.Length", background = "pink") %>%
flair("Species", color = "CornflowerBlue")
iris %>%
group_by(Species) %>%
summarize(mean(Sepal.Length))
decorate('how_to_pipe') %>%
flair_lines(2:3)
ggplot(iris, aes(x = Sepal.Length,
y = Petal.Length,
color = Species)) +
geom_point()
decorate('
ggplot(iris, aes(x = Sepal.Length,
y = Petal.Length,
color = Species)) +
geom_point()
') %>%
flair_args(color = "CornflowerBlue") %>%
flair_funs(color = "Coral", underline = TRUE) %>%
flair_input_vals(background = "Aquamarine") %>%
flair_rx("[A-z]*\\.Length", background = "pink")
foo <- mean(1:10)
decorate('foo <- mean(1:10)') %>%
flair_funs()
foo + 5
mean(1:10)
foo <- decorate('mean(1:10)') %>%
flair_funs()
foo + 5 |
generateJAGSlhd.nbinom <- function(jags.model.args,
mean.model,
dispersion.model,
rounding,
residuals,
include.checks){
string <- c("\t\t
"\t\t y[i] ~ dnegbin(p[i],r[i])\n\n")
if(rounding){
string <- c(string,
generateJAGSrounding(jags.model.args))
}
string <- c(string,
"\t\t
if(is.null(dispersion.model$weights))
string <- c(string,
"\t\t r[i] <- 1/phi[i]\n",
"\t\t p[i] <- 1/(1 + phi[i] * muy[i])\n")
else
stop("Weights are currently not supported for the negative binomial model.\n")
string <- c(string,
"\t\t vary[i] <- muy[i] / p[i]\n",
"\t\t sdy[i] <- sqrt(vary[i])\n\n")
if(include.checks){
string <- c(string,
generateJAGSchecks(jags.model.args,
"(muy[i] > 0)",
"(phi[i] > 0)"))
}
if(residuals){
string <- c(string,
"\t\t
"\t\t resid[i] <- (y[i] - muy[i])/sdy[i]\n\n")
}
string
}
|
Return <- DATE(2020,1,1)
expect_equal(Return,as.Date("2020-1-1")) |
pinLoss <- function(y, mu, qu, add = TRUE){
if( length(qu) > 1 ){
n <- length( qu )
l <- sapply(1:n,
function(ii){
return( pinLoss(y, mu[ , ii], qu[ii], add = add) )
})
if( is.matrix(l) ){ colnames(l) <- qu } else { names(l) <- qu }
return( l )
}
tau <- 1 - qu
d <- y - mu
l <- d * 0
l[d < 0] <- - tau * d[ d < 0 ]
l[d > 0] <- - (tau-1) * d[ d > 0 ]
if( add ){ l <- sum(l) }
return( l )
} |
context("get common ids from set of objects")
test_that("get_common_ids works", {
x <- matrix(1:20, nrow=5, ncol=4)
rownames(x) <- LETTERS[1:5]
y <- 1:5
names(y) <- c("A", "C", "D", "E", "F")
z <- array(1:(5*2*3), dim=c(5, 2, 3))
dimnames(z) <- list(c("G", "C", "D", "G", "A"),
c("col1", "col2"),
c("depth1", "depth2", "depth3"))
expect_error(get_common_ids(x, y, z))
expect_error(get_common_ids(z, y, x))
expect_error(get_common_ids(x, z, y))
rownames(z)[4] <- "H"
expect_equal(get_common_ids(x, y, z), c("A", "C", "D"))
expect_equal(get_common_ids(x, z, y), c("A", "C", "D"))
expect_equal(get_common_ids(z, y, x), c("C", "D", "A"))
rownames(z)[4] <- "H"
chvec <- c("A", "I", "D", "E")
expect_equal(get_common_ids(x, y, z, chvec), c("A", "D"))
expect_equal(get_common_ids(x, z, chvec, y), c("A", "D"))
expect_equal(get_common_ids(z, chvec, y, x), c("D", "A"))
x <- as.data.frame(x)
rownames(z)[4] <- "G"
expect_error(get_common_ids(x, y, z))
expect_error(get_common_ids(z, y, x))
expect_error(get_common_ids(x, z, y))
rownames(z)[4] <- "H"
expect_equal(get_common_ids(x, y, z), c("A", "C", "D"))
expect_equal(get_common_ids(x, z, y), c("A", "C", "D"))
expect_equal(get_common_ids(z, y, x), c("C", "D", "A"))
})
test_that("get_common_ids works when complete.cases=TRUE", {
n <- 10
x <- matrix(rnorm(10*n), ncol=10)
rownames(x) <- LETTERS[1:10]
y <- matrix(rnorm(5*(n-1)), ncol=5)
rownames(y) <- LETTERS[(1:(n-1))+2]
z <- LETTERS[c(3:8, 15:18)]
expected <- LETTERS[3:8]
expect_equal(get_common_ids(x, y, z, complete.cases=TRUE), expected)
expect_equal(get_common_ids(y, x, z, complete.cases=TRUE), expected)
expect_equal(get_common_ids(z, y, x, complete.cases=TRUE), expected)
x[1,c(5,7)] <- NA
x[3,c(2,8,9)] <- NA
x[5,4] <- NA
y[3,5] <- NA
y[6,] <- NA
expected <- c("D", "F", "G")
expect_equal(get_common_ids(x, y, z, complete.cases=TRUE), expected)
expect_equal(get_common_ids(y, x, z, complete.cases=TRUE), expected)
expect_equal(get_common_ids(z, y, x, complete.cases=TRUE), expected)
}) |
cdm_fit_normal <- function(x, w)
{
theta.k <- x
if ( is.vector(theta.k) ){
theta.k <- matrix( theta.k, ncol=1 )
}
D <- ncol(theta.k)
if (D==1){
mg <- sum( theta.k[,1] * w )
sdg <- sum( theta.k[,1]^2 * w ) - mg^2
}
if (D>1){
mean.gg <- rep(0,D)
Sigma.gg <- diag(0,D)
for (dd in 1:D){
mean.gg[dd] <- sum( w * theta.k[,dd] )
}
for (dd1 in 1:D){
for (dd2 in dd1:D){
Sigma.gg[dd1,dd2] <- sum( w * (theta.k[,dd1] - mean.gg[dd1] )*(theta.k[,dd2] - mean.gg[dd2] ) )
Sigma.gg[dd2,dd1] <- Sigma.gg[dd1,dd2]
}
}
mg <- mean.gg
sdg <- Sigma.gg
}
res <- list( Mu=mg, Sigma=sdg)
return(res)
} |
suppressPackageStartupMessages(library(dequer))
l <- as.list(1:10)
q <- queue()
for (i in 1:10) pushback(q, i)
s <- stack()
for (i in 10:1) push(s, i)
lq <- as.list(q)
ls <- as.list(s)
stopifnot(all.equal(l, lq))
stopifnot(all.equal(l, ls))
dq <- as.deque(q)
ds <- as.deque(s)
ldq <- as.list(dq)
lds <- as.list(ds)
stopifnot(all.equal(l, ldq))
stopifnot(all.equal(l, lds)) |
read.mirt <- function (x, as.irt.pars = TRUE, ...)
{
if(requireNamespace("plink", quietly = TRUE)){
if(class(x) == 'MultipleGroupClass'){
pars <- vector('list', length(extract.mirt(x, 'pars')))
for(i in 1:length(pars)){
tmp <- extract.group(x, group=i)
pars[[i]] <- read.mirt(tmp, as.irt.pars=as.irt.pars, ...)
}
names(pars) <- extract.mirt(x, 'groupNames')
return(pars)
} else if(is.list(x)){
pars <- vector('list', length(x))
names(pars) <- names(x)
for(i in 1:length(pars))
pars[[i]] <- read.mirt(x[[i]], as.irt.pars=as.irt.pars, ...)
return(pars)
}
if(class(x) == 'MixedClass')
stop('Mixed effect models not supported.', call.=FALSE)
if(length(extract.mirt(x, 'prodlist')))
stop('Polynomial factor models not supported in plink', call.=FALSE)
nfact <- extract.mirt(x, 'nfact')
nitems <- extract.mirt(x, 'nitems')
listpars <- coef(x, IRTpars=ifelse(nfact == 1, TRUE, FALSE), rotate='none', verbose=FALSE, ...)
if(!is(listpars[[1]], 'matrix'))
for(i in 1:nitems)
listpars[[i]] <- t(matrix(listpars[[i]]))
mirt.items <- as.character(lapply(extract.mirt(x, 'pars'), class))
mirt.items <- plink.items <- mirt.items[-(nitems+1)]
cat <- numeric(nitems)
pars <- matrix(NA, nitems, 40)
theta <- -4:4
Theta <- thetaComb(theta, nfact)
K <- extract.mirt(x, 'K')
for(i in 1:nitems){
if(mirt.items[i] == 'dich'){
plink.items[i] <- 'drm'
cat[i] <- 2
abc <- listpars[[i]][1, 1:(nfact+2)]
pars[i, 1:length(abc)] <- abc
next
}
if(mirt.items[i] == 'graded'){
plink.items[i] <- 'grm'
ab <- listpars[[i]][1, ]
cat[i] <- K[i]
pars[i, 1:length(ab)] <- ab
next
}
if(mirt.items[i] == 'rsm'){
stop('Rasch rating scale models not supported for now', call.=FALSE)
}
if(mirt.items[i] == 'nestlogit'){
stop('nestlogit models not supported in plink', call.=FALSE)
}
if(mirt.items[i] == 'rating'){
stop('rating model not supported for now', call.=FALSE)
plink.items[i] <- 'grm'
ab <- listpars[[i]][1, ]
adj <- ab[length(ab)]
ab <- ab[-length(ab)]
cat[i] <- K[i]
for(j in 1:(cat[i] - 1))
ab[j + nfact] <- ab[j+1] + adj
pars[i, 1:length(ab)] <- ab
next
}
if(mirt.items[i] == 'gpcm'){
ab <- listpars[[i]][1, ]
a <- ab[1:nfact]
ab <- ab[-(1:nfact)]
cat[i] <- K[i]
if(nfact == 1L){
pars[i, 1:length(ab)] <- ab
} else {
stop('Multidimensional gpcm not yet supported', call.=FALSE)
}
next
}
if(mirt.items[i] == 'nominal'){
plink.items[i] <- 'nrm'
ab <- listpars[[i]][1, ]
cat[i] <- K[i]
if(nfact == 1L){
pars[i, 1:length(ab)] <- ab
} else {
stop('Multidimensional nrm not yet supported', call.=FALSE)
}
next
}
if(mirt.items[i] == 'partcomp'){
stop('Partially compensatory models not supported in plink', call.=FALSE)
}
if(mirt.items[i] == 'custom'){
stop('User defined models not supported in plink', call.=FALSE)
}
}
model <- unique(plink.items)
items <- vector('list', length(model))
index <- 1:nitems
for(i in 1:length(model))
items[[i]] <- index[model[i] == plink.items]
pm <- plink::as.poly.mod(nitems, model=model, items=items)
pars <- pars[ , colSums(is.na(pars)) != nitems]
if(as.irt.pars)
pars <- plink::as.irt.pars(pars, cat=cat, poly.mod=pm, dimensions=nfact, ability=Theta)
return(pars)
} else {
stop('plink package is not available. Please install.', call.=FALSE)
}
} |
col2hex <- function(cname) {
res <- try(colMat <- col2rgb(cname), silent=TRUE)
if (class(res)!="try-error") {
rgb(red=colMat[1,]/255, green=colMat[2,]/255, blue=colMat[3,]/255)
} else {
res
}
}
is.Color <- function(x) {
vapply(x, is.Color2, logical(1))
}
is.Color2 <- function(x) {
ErrFnd <- FALSE
if (is.numeric(x)) {
if (x < 0) {
ErrFnd <- TRUE
} else {
x <- as.character(x)
}
}
if (!ErrFnd) {
if (is.factor(x)) x <- as.character(x)
if (is.character(x)) {
if (!is.na(match(x,c(as.character(c(1:8)),grDevices::colors())))) {
TRUE
} else {
res <- try(col2rgb(x),silent=TRUE)
return(!"try-error"%in%class(res))
}
} else {
FALSE
}
}
}
printNamedList <- function(n,x) {
cat("Named List - ",n,"\n")
if (!is.list(x)) {
xmsg <- paste0("Variable passed to print named list ia not a list structure. Printed in raw format.")
warning(xmsg, call.=FALSE)
print(x)
} else {
xN <- sort(names(x))
if (is.null(xN)) {
print(x)
} else {
xNMax <- max(nchar(xN))
xSp <- paste0(rep(" ",xNMax),collapse="")
for (N in xN) {
wN <- stringr::str_sub(paste0(N,xSp),1,xNMax)
wM <- paste0(wN,":",paste0(x[N],collapse=", "))
cat(wM,"\n")
}
cat("\n")
}
}
}
convertPROJ4 <- function (x) {
save_x <- x
y <- NULL
ErrFnd <- FALSE
if (!is.character(x)) {
ErrFnd <- TRUE
xmsg <- paste0("***903 The proj4 call parameter is not a valid character vector. Must be a valid proj4 argument character string to be converted.")
warning(xmsg,call.=FALSE)
return(FALSE)
} else {
res <- tryCatch({
y <- sp::CRS(x)
}, warning = function(war) {
return(paste0("WARNING:",war))
}, error = function(err) {
return(paste0("ERROR:",err))
}, finally = {
}
)
if (class(res) == "CRS") {
return(res)
} else {
res <- as.character(res)
if (stringr::str_sub(res,1,6) == "ERROR:" ) {
xmsg <- paste0("***900 The provided proj4 string encountered an error when converted to the \n",
" internal CRS parameter. The following error was reported, plesae correct and rerun.\n",
" ",stringr::str_sub(res,7,200),"\n")
warning(xmsg,call.=FALSE)
ErrFnd = TRUE
} else {
if (stringr::str_sub(res,1,8) == "WARNING:") {
xmsg <- paste0("***901 The provided proj4 string encountered an warning when converted to the \n",
" internal CRS parameter. The following warning was reported, plesae correct and rerun.\n",
" ",stringr::str_sub(res,9,200),"\n")
warning(xmsg,call.=FALSE)
ErrFnd = TRUE
} else {
xmsg <- paste0("***902 Unpredicted results when proj4 was translated to CRS format. Unknown problem.\n",
" ",res,"\n")
warning(xmsg,call.=FALSE)
ErrFnd = TRUE
}
}
return(FALSE)
}
}
}
SM_GlobInit <- function() {
rPM <- NULL
rPM$debugFlag <- FALSE
rPM$debug <- FALSE
RCBrewerDF <- RColorBrewer::brewer.pal.info
RCBrewerDF$PName <- row.names(RCBrewerDF)
RCBrewerDF$category <- as.character(RCBrewerDF$category)
RCBrewerDF$Name <- toupper(RCBrewerDF$PName)
rPM$RCBrewerDF <- RCBrewerDF
rPM$palColors <- "RdYlBu"
rPM$palColorsMaxNum <- 11
rPM$ColorB_O_Region <- "grey10"
rPM$ColorB_O_State <- "grey14"
rPM$ColorB_O_Seer <- "grey18"
rPM$ColorB_O_Hsa <- "grey22"
rPM$ColorB_O_Group <- "grey23"
rPM$ColorB_O_County <- "grey26"
rPM$ColorB_O_Tract <- "grey30"
rPM$ColorB_hatching <- grey(0.66)
rPM$ColorB_Data <- "black"
rPM$palColors <- "RdYlBu"
rPM$CB_Rate_Mid <- rev(RColorBrewer::brewer.pal(5,rPM$palColors))
rPM$CB_Rate_Mid2 <- rPM$CB_Rate_Mid
rPM$numberTestRegExpr <- "^[:space:]*[+-]?[:blank:]?((([0-9]{1,3}[,])?([0-9]{3}[,])*[0-9]{3})|([0-9]*))?(([.][0-9]*)|)([eE][-+]?[0-9]+)?[:space:]*$"
rPM$OrigCRS <- sp::CRS("+proj=longlat +datum=NAD83")
rPM$ProjCRS <- sp::CRS("+proj=aea +lat_1=33 +lat_2=49 +lat_0=39 +lon_0=96w +units=m")
rPM$proj4 <- NA
rPM$CRSproj4 <- NA
rPM$rg99Data <- data.frame(region=c("1","2","3","4"),
rgName=c("NorthEast","South","Midwest","West"),
stringsAsFactors=FALSE)
SeerNames <-matrix(c(
"AK-NAT","Alaska", "AK", "02", 27, "4",
"AZ-NAT","Arizona", "AZ", "04", 15, "4",
"CA-LA", "Los Angeles", "CA", "06", 1, "4",
"CA-OTH","California excl","CA", "06", 48, "4",
"CA-OTH","Greater Calif", "CA", "06", 48, "4",
"CA-SF", "San Fran", "CA", "06", 5, "4",
"CA-SJ", "San Jose", "CA", "06", 4, "4",
"CT", "Connecticut", "CT", "09", 8, "1",
"GA-ATL","Atlanta", "GA", "13", 5, "2",
"GA-OTH","Georgia other", "GA", "13",144, "2",
"GA-OTH","Greater Geor", "GA", "13",144, "2",
"GA-RUR","Rural Georg", "GA", "13", 10, "2",
"HI", "Hawaii", "HI", "15", 5, "4",
"IA", "Iowa", "IA", "19", 99, "3",
"KY", "Kentucky", "KY", "21",120, "2",
"LA", "Louisiana", "LA", "22", 64, "2",
"MI-DET","Detroit", "MI", "26", 3, "3",
"NJ", "New Jersey", "NJ", "34", 21, "1",
"NM", "New Mexico", "NM", "35", 33, "4",
"OK-CHE","Cherokee", "OK", "40", 14, "2",
"UT", "Utah", "UT", "49", 29, "4",
"WA-SEA","Puget", "WA", "53", 13, "4",
"WA-SEA","Seattle", "WA", "53", 13, "4"
),
ncol = 6, byrow=TRUE)
SeerNames <- as.data.frame(SeerNames,stringsAsFactors=FALSE)
colnames(SeerNames) <- c("ab","alias","stAbbr","stID","coCnt","rgID")
SeerNames$ab <- toupper(SeerNames$ab)
SeerNames$alias <- toupper(SeerNames$alias)
SeerNames$stAbbr <- toupper(SeerNames$stAbbr)
SeerNames$stID <- as.character(SeerNames$stID)
rPM$SeerNames <- SeerNames
rPM$cYear <- "00"
rPM$censusYear <- "2000"
rPM$cY <- ""
rPM$ndf <- data.frame(FIPS=c("01","02"),Rate=c(1.1,1.2),stringsAsFactors=FALSE)
rPM$ndfName <- "ndf"
rPM$ndfColNames <- c("FIPS","Rate")
rPM$ndfColMax <- 2
rPM$idMode <- 0
rPM$idCol <- "FIPS"
rPM$idColName <- "FIPS"
rPM$idColNum <- 0
rPM$dataCol <- "pValue"
rPM$dataColName <- "pValue"
rPM$dataColNum <- 0
rPM$categMode <- 1
rPM$categ <- 5
rPM$wCateg <- 5
rPM$CatNumb <- 5
rPM$CatR <- c("")
rPM$CatRAdj <- c("")
rPM$CatRwCnt <- c("")
rPM$brkPtDigits <- 2
rPM$stateSelDel <- c("")
rPM$AspRatio <- 1
rPM$HatchFlag <- FALSE
rPM$hatch_caller <- FALSE
rPM$hatch <- list(hDataCol=character(),hDataColName=character(),hDataColNum=numeric(),
hData=numeric(),
hOps=character(),
hValue=numeric(),
hRange=numeric(),
hLab=character(),
hAngle=numeric(),
hRes=logical(),
hCol=character(),
hLwd=numeric(),
hDen=numeric(),
incAngle=numeric()
)
rPM$Hatch2Flag <- FALSE
rPM$hatch2_caller <- FALSE
rPM$hatch2 <- list(hDataCol=character(),hDataColName=character(),hDataColNum=numeric(),
hData=numeric(),
hOps=character(),
hValue=numeric(),
hRange=numeric(),
hLab=character(),
hAngle=numeric(),
hRes=logical(),
hCol=character(),
hLwd=numeric(),
hDen=numeric()
)
rPM$mLegendFlag <- FALSE
rPM$mLegend_caller <- FALSE
rPM$mLegend <- list(lCounts=logical(),lSize=numeric(),lNumCols=numeric(),
lPos=character(),lPosv=character(),
lNoValue=logical(),lPch=numeric(),lLabels=character())
rPM$dataBCol <- "grey90"
rPM$dataBCol_caller <- FALSE
rPM$data_lwd <- 0.75
rPM$tr_lwd <- 0.75
rPM$co_lwd <- 1.0
rPM$hs_lwd <- 1.5
rPM$sa_lwd <- 2.0
rPM$st_lwd <- 2.5
rPM$rg_lwd <- 2.5
rPM$mTitle <- c()
rPM$mTitle.cex <- 1
rPM$HSA <- FALSE
rPM$GROUPS <- FALSE
rPM$regionB <- "NONE"
rPM$regionB_caller <- FALSE
rPM$stateB <- "NONE"
rPM$stateB_caller <- FALSE
rPM$seerB <- "NONE"
rPM$seerB_caller <- FALSE
rPM$hsaB <- "NONE"
rPM$hsaB_caller <- FALSE
rPM$countyB <- "NONE"
rPM$countyB_caller <- FALSE
rPM$tractB <- "NONE"
rPM$tractB_caller <- FALSE
rPM$fillTo <- "NONE"
rPM$fillTo_caller <- FALSE
rPM$clipTo <- "NONE"
rPM$clipTo_caller <- FALSE
rPM$dataMapDF <- data.frame(ID=c("01","02"),data=c("1.2","1.3"),hData=c(1,2),h2Data=c(1,2),stringsAsFactors=FALSE)
rPM$NumErrors <- 0
rPM$NumWarnings <- 0
return(rPM)
}
SM_Hatching <- function(rPM) {
SetUpHatch <- function(whatch,lhatch) {
maphData <- whatch$hData
numberTestRegExpr <- rPM$numberTestRegExpr
if (is.factor(maphData)) {
maphData <- as.character(maphData)
}
if (!is.numeric(maphData)) {
if (!is.character(maphData)) {
xmsg <- paste0("***144 The ",lhatch," data column ",whatch$hDataColName,
" does not contain numbers. Parameter ",lhatch," disabled.")
warning(xmsg, call.=FALSE)
whatch$flag <- FALSE
} else {
hDataT <- gregexpr(numberTestRegExpr,maphData)
HNumOK <- (hDataT == 1)
if (all(HNumOK)) {
maphData <- as.numeric(maphData)
if (any(is.na(maphData))) {
xmsg <- paste0("***145 The ",lhatch," data is not numeric. Parameter ",lhatch," disabled.")
warning(xmsg,call.=FALSE)
whatch$flag <- FALSE
}
} else {
xmsg <- paste0("***146 The ",lhatch," data column ",whatch$hDataColName,
" does not contain valid numbers. Parameter ",lhatch," is disabled.")
warning(xmsg, call.=FALSE)
whatch$flag <- FALSE
}
}
}
if (whatch$flag) {
H_range <- whatch$hRange
if (!is.na(H_range)) {
x1 <- maphData < H_range[1]
x2 <- maphData > H_range[2]
if (any(x1 | x2)) {
xmsg <- paste0("***147 ",lhatch," data provided is not within the allowed range :",
whatch$hRange[1]," to ",whatch$hRange[2],". Parameter ",lhatch," disabled.")
warning(xmsg, call.=FALSE)
whatch$flag <- FALSE
}
}
}
H_res <- rep(FALSE,length(maphData))
if (whatch$flag) {
wstr <- paste0("maphData ",whatch$hOps," ",whatch$hValue)
H_res <- eval(parse(text=wstr))
whatch$hRes <- H_res
}
return(whatch)
}
debug <- rPM$debug
debugFlag <- rPM$debugFlag
dataMapDF <- rPM$dataMapDF
HatchFlag <- rPM$HatchFlag
if (HatchFlag) {
hatch <- rPM$hatch
hatch$flag <- HatchFlag
hatch$hData <- dataMapDF$hData
hatch <- SetUpHatch(hatch,"hatch")
HatchFlag <- hatch$flag
dataMapDF$hRes <- hatch$hRes
if (debug) {
cat("Hatching FINAL settings Z-1814 Flag:",HatchFlag,"\n")
cat(" parameters -- dataCol:",hatch$hDataColName,"
cat(" range:",hatch$hRange,"\n")
cat(" col :",hatch$hCol," lwd:",hatch$hLwd,
" den:",hatch$hDen," angle:",hatch$hAngle," incAngle:",hatch$hIncAngle,"\n")
cat("dataMapDF:\n")
print(str(dataMapDF))
}
rPM$HatchFlag <- HatchFlag
rPM$hatch <- hatch
}
Hatch2Flag <- rPM$Hatch2Flag
if (Hatch2Flag) {
hatch2 <- rPM$hatch2
hatch2$flag <- Hatch2Flag
hatch2$hData <- dataMapDF$h2Data
hatch2 <- SetUpHatch(hatch2,"hatch2")
Hatch2Flag <- hatch2$flag
dataMapDF$h2Res <- hatch2$hRes
if (debug) {
cat("Hatching
cat(" parameters -- dataCol:",hatch2$hDataColName,"
cat(" range:",hatch2$hRange,"\n")
}
rPM$Hatch2Flag <- Hatch2Flag
rPM$hatch2 <- hatch2
}
rPM$dataMapDF <- dataMapDF
return(rPM)
}
SM_Build <- function(rPM) {
loadBoundary2 <- function(rPM, DSList) {
DDir <- "H:/work/GIS/Rpackage/V1.2.2/"
DVer <- "-1.2.2/data/"
if (!rPM$debugFlag) {
loadMatch <- match(DSList$DSN,rPM$loadedDataSetList)
loadMissing <- is.na(loadMatch)
} else {
loadMissing <- FALSE
}
if (any(loadMissing)) {
ErrFnd <- TRUE
xmsg <- paste0("***196 The following boundary datasets are missing. Make sure the appropriate SeerMapper",rPM$cY," supplement packages have been installed and loaded.")
warning(xmsg, call.=FALSE)
loadListMiss <- DSList$DSN[loadMissing]
xmsg <- paste0("***197 Missing:",paste0(loadListMiss,collapse=", "),"\n")
stop(xmsg, call.=FALSE)
rm(loadListMiss)
}
work_set <- NULL
for (inx in seq(dim(DSList)[1])) {
loadImage <- DSList[inx,"DSN"]
loadImPkg <- DSList[inx,"Pkg"]
if (rPM$debugFlag) {
DSN_FN <- paste0(DDir,loadImPkg,DVer,loadImage,".rda")
load(file=DSN_FN,envir=environment())
} else {
data(list=loadImage,envir=environment(),package=loadImPkg)
}
new_bnd <- get(loadImage)
new_idList <- row.names(new_bnd)
new_spdf <- new_bnd
if (class(new_spdf) == "SpatialPolygons") {
idDF <- data.frame(ID=new_idList,row.names=new_idList,stringsAsFactors=FALSE)
new_spdf <- SpatialPolygonsDataFrame(new_bnd,idDF)
}
if (class(new_spdf) == "SpatialPolygonsDataFrame" ) {
new_spdf@data$ID <- new_idList
} else {
xmsg <- paste0("***980 Internal Error. Boundary DS :",loadImage," is not a SpatialPolygonsDataFrame.")
stop(xmsg,call.=FALSE)
}
if (length(work_set) == 0) {
work_set <- new_spdf
} else {
work_set@proj4string <- new_spdf@proj4string
work_set <- spRbind(work_set,new_spdf)
}
eStr2 <- paste0("suppressWarnings(rm(",loadImage,"))")
eval(parse(text=eStr2))
}
return(work_set)
}
ErrFnd <- FALSE
StopFnd <- FALSE
debugFlag <- rPM$debugFlag
debug <- rPM$debug
censusYear <- rPM$censusYear
cYear <- rPM$cYear
cY <- rPM$cY
stateSelDel <- rPM$stateSelDel
ndfName <- rPM$ndfName
idMode <- rPM$idMode
categMode <- rPM$categMode
dataMapDF <- rPM$dataMapDF
MV <- NULL
rg99_d00 <- NULL
st99_d00 <- NULL
sa99_d00 <- NULL
hs99_d00 <- NULL
co99_d00 <- NULL
rgDataSet <- paste0("rg99_d00")
stDataSet <- paste0("st99_d00")
saDataSet <- paste0("sa99_d00")
hsDataSet <- paste0("hs99_d00")
coDataSet <- paste0("co99_d00")
DDir <- "H:/work/GIS/Rpackage/V1.2.2/"
DVer <- "-1.2.2/data/"
if (debugFlag) {
cat("datasets via load().\n")
load(file=paste0(DDir,"SeerMapper",DVer,rgDataSet,".rda"),envir=environment())
load(file=paste0(DDir,"SeerMapper",DVer,stDataSet,".rda"),envir=environment())
load(file=paste0(DDir,"SeerMapper",DVer,saDataSet,".rda"),envir=environment())
load(file=paste0(DDir,"SeerMapper",DVer,hsDataSet,".rda"),envir=environment())
load(file=paste0(DDir,"SeerMapper",DVer,coDataSet,".rda"),envir=environment())
} else {
data(list=rgDataSet,envir=environment(),package="SeerMapper")
data(list=stDataSet,envir=environment(),package="SeerMapper")
data(list=saDataSet,envir=environment(),package="SeerMapper")
data(list=hsDataSet,envir=environment(),package="SeerMapper")
data(list=coDataSet,envir=environment(),package="SeerMapper")
}
regions_set <- NULL
regions_data <- NULL
regions_proj <- NULL
rg_proj_sel <- NULL
states_set <- NULL
states_data <- NULL
states_proj <- NULL
st_proj_sel <- NULL
SeerRegs_set <- NULL
SeerRegs_data <- NULL
SeerRegs_proj <- NULL
sa_proj_sel <- NULL
hs99_mapr <- NULL
co99_mapr <- NULL
states_set <- get(stDataSet)
StateListFull <- as.character(row.names(states_set))
MV$StateListFull <- StateListFull
StateListAll <- StateListFull
if (length(stateSelDel) > 0 ) {
sLInxAllKp <- is.na(match(StateListAll,stateSelDel))
StateListAll <- StateListAll[sLInxAllKp]
}
MV$StateListAll <- StateListAll
states_set <- states_set[StateListAll,]
states_proj <- states_set
states_data <- states_proj@data
if (!is.null(rPM$CRSproj4)) {
states_proj <- sp::spTransform(states_set,CRSobj=rPM$CRSproj)
c_XY<-t(sapply(slot(states_proj,"polygons"), function(x) c(x@ID,x@labpt[1],x@labpt[2])))
colnames(c_XY)<-c("ID","c_X","c_Y")
states_proj@data[,c("c_X","c_Y")]<-c_XY[,c("c_X","c_Y")]
}
states_data <- states_proj@data
rm(stDataSet)
MV$states_proj <- states_proj
MV$states_data <- states_data
SeerRegs_set <- get(saDataSet)
SeerRegs_proj <- SeerRegs_set
if (!is.null(rPM$CRSproj4)) {
SeerRegs_proj <- sp::spTransform(SeerRegs_set,CRSobj=rPM$CRSproj)
c_XY<-t(sapply(slot(SeerRegs_proj,"polygons"), function(x) c(x@ID,x@labpt[1],x@labpt[2])))
colnames(c_XY)<-c("ID","c_X","c_Y")
SeerRegs_proj@data[,c("c_X","c_Y")]<-c_XY[,c("c_X","c_Y")]
}
SeerRegs_data <- SeerRegs_proj@data
SeerRegListAll <- SeerRegs_data$saID
SeerRegListAll <- na.omit(SeerRegListAll)
MV$SeerRegListAll <- SeerRegListAll
rm(saDataSet)
MV$SeerRegs_proj <- SeerRegs_proj
MV$SeerRegs_data <- SeerRegs_data
if (debug) {
cat("SeerRegs_proj RN Z-2285 :",paste0(row.names(SeerRegs_proj),collapse=", "),"\n")
}
regions_set <- get(rgDataSet)
regions_data <- regions_set@data
regions_proj <- regions_set
if (!is.null(rPM$CRSproj4)) {
regions_proj <- sp::spTransform(regions_set,CRSobj=rPM$CRSproj)
}
RegionListAll <- as.character(row.names(regions_proj))
MV$regions_proj <- regions_proj
MV$regions_data <- regions_data
MV$RegionListAll <- RegionListAll
hs99_mapr <- get(hsDataSet)
MV$hs99_mapr <- hs99_mapr
co99_mapr <- get(coDataSet)
co99_mapr$ID <- row.names(co99_mapr)
co99_mapr$stID <- stringr::str_sub(co99_mapr$ID,1,2)
co99_mapr$stcoID <- co99_mapr$ID
co99_mapr$stcotrID <- NA
co99_mapr$stName <- states_data[co99_mapr$stID,"stName"]
co99_mapr$stAbbr <- states_data[co99_mapr$stID,"abbr"]
co99_mapr <- co99_mapr[,c("ID","stID","stAbbr","stName","stcoID","coName","stcotrID","saID","HSAID","c_X_00","c_Y_00","c_X_10","c_Y_10","tracts_00","tracts_10","y")]
MV$co99_mapr <- co99_mapr
dataMapID <- dataMapDF$ID
rPM$dataMapDF <- dataMapDF
idNA <- is.na(dataMapID)
if (any(idNA)) {
xmsg <- paste0("***220 Some of the data rows in the ",rPM$ndfName," data.frame have location IDs with missing values (NA). These rows will be removed. Correct and rerun.")
warning(xmsg, call.=FALSE)
NAList <- dataMapDF$rSeq[idNA]
xmsg <- paste0("***222 The following rows will not be mapped: ",paste0(NAList,collapse=", "))
warning(xmsg, call.=FALSE)
dataMapDF <- dataMapDF[!idNA,]
dataMapID <- dataMapDF$ID
}
idLenR <- range(nchar(dataMapID))
idType <- grepl("^[0-9]*$",dataMapID)
idLenMax <- idLenR[2]
idMode <- NA
idGroup <- ""
data_proj <- NULL
data_data <- NULL
dataListAll <- NA
dataListData <- NA
loadDetails <- FALSE
if (all(idType)) {
if (idLenMax == 2 || idLenMax == 1) {
dataMapID <- as.character(stringr::str_sub(paste0("0",dataMapID),-2,-1))
xm <- match(dataMapID,StateListAll)
xmNA <- is.na(xm)
xmCnt <- sum(xmNA)
if (xmCnt > 0) {
xmsg <- paste0("***206 The location IDs contain invalid state IDs. Assuming the Location IDs are HSA numbers.")
warning(xmsg, call.=FALSE)
idLenMax <- 3
} else {
loadDetails <- FALSE
idGroup <- NA
idMode <- 1
dataMapDF$ID <- dataMapID
dataMapDF$stID <- dataMapID
dataMapDF$stcoID <- NA
dataMapDF$stcotrID <- NA
dataMapDF$saID <- NA
dataMapDF$HSAID <- NA
data_proj <- states_proj
data_data <- states_data
}
}
if (idLenMax == 3) {
loadDetails <- TRUE
idGroup <- "hs"
idMode <- 5
dataMapID <- stringr::str_sub(paste0("00",dataMapID),-3,-1)
dataMapDF$ID <- dataMapID
dataMapDF$stID <- hs99_mapr[dataMapID,"stID"]
dataMapDF$stcoID <- NA
dataMapDF$stcotrID <- NA
dataMapDF$saID <- hs99_mapr[dataMapID,"saID"]
dataMapDF$HSAID <- dataMapID
}
if (idLenMax == 5 || idLenMax == 4) {
loadDetails <- TRUE
idGroup <- "co"
idMode <- 2
dataMapID <- stringr::str_sub(paste0("000",dataMapID),-5,-1)
dataMapDF$ID <- dataMapID
dataMapDF$stID <- stringr::str_sub(dataMapID,1,2)
dataMapDF$stcoID <- dataMapID
dataMapDF$stcotrID <- NA
dataMapDF$saID <- co99_mapr[dataMapDF$stcoID,"saID"]
dataMapDF$HSAID <- co99_mapr[dataMapDF$stcoID,"HSAID"]
}
if (idLenMax == 11 || idLenMax == 10) {
loadDetails <- TRUE
idGroup <- "tr"
idMode <- 3
dataMapID <- as.character(stringr::str_sub(paste0("0",dataMapID),-11,-1))
dataMapDF$ID <- dataMapID
dataMapDF$stID <- stringr::str_sub(dataMapID,1,2)
dataMapDF$stcoID <- stringr::str_sub(dataMapID,1,5)
dataMapDF$stcotrID <- dataMapID
dataMapDF$saID <- co99_mapr[dataMapDF$stcoID,"saID"]
dataMapDF$HSAID <- co99_mapr[dataMapDF$stcoID,"HSAID"]
dataListAll <- NA
}
if (idMode != 5) dataMapDF$stID <- stringr::str_sub(dataMapDF$ID,1,2)
} else {
if (all(!idType)) {
SeerNames <- rPM$SeerNames
SeerAbbr <- toupper(dataMapID)
numEntries <- length(SeerAbbr)
SeerAbbrRes <- rep(NA,numEntries)
SeerAbbrMatch <- match(SeerAbbr,SeerRegListAll)
SeerAbbrMiss <- is.na(SeerAbbrMatch)
SeerAbbrRes <- SeerRegListAll[SeerAbbrMatch]
if (any(SeerAbbrMiss)) {
SeerAliasMatch <- rep(NA,numEntries)
SeerROuta <- t( sapply(c(1:length(SeerNames$alias)),
function(x) {
y=grep(SeerNames$alias[x],SeerAbbr,ignore.case=TRUE)
ifelse(length(y)==0,return(c(NA,NA)),return(c(x,y)))
}
)
)
SeerROutb <- SeerROuta[!is.na(SeerROuta[,1]),]
SeerAliasMatch[SeerROutb[,2]] <- SeerROutb[,1]
SeerAliasMiss <- is.na(SeerAliasMatch)
SeerAliasRes <- SeerNames$ab[SeerAliasMatch]
SeerAbbrRes[!SeerAliasMiss] <- SeerAliasRes[!SeerAliasMiss]
SeerRegMiss <- SeerAbbrMiss & SeerAliasMiss
dataMapDF$good <- !SeerRegMiss
dataMapID[!SeerRegMiss] <- SeerAbbrRes[!SeerRegMiss]
dataMapDF$ID <- dataMapID
if (any(SeerRegMiss)) {
badList <- SeerAbbr[SeerRegMiss]
xmsg <- paste0("***300 The following Seer Registry idenifiers do not match the abbreviations or aliases:")
ymsg <- paste0("***301 ",paste0(badList,collapse=", "))
zmsg <- paste0("***302 These data rows will be ignored in the mapping.")
warning(xmsg,call.=FALSE)
warning(ymsg,call.=FALSE)
warning(zmsg,call.=FALSE)
}
}
loadDetails <- FALSE
idGroup <- NA
idMode <- 4
dataMapDF$ID <- dataMapID
dataMapDF$saID <- dataMapID
srMatch <- match(dataMapID,SeerRegs_data$saID)
dataMapDF$stID <- SeerRegs_data[srMatch,"stID"]
dataMapDF$stcoID <- NA
dataMapDF$stcotrID <- NA
dataMapDF$HSAID <- NA
data_proj <- SeerRegs_proj
data_data <- SeerRegs_data
} else {
ErrFnd <- TRUE
xmsg <- paste0("***011 The Location IDs in column ",rPM$idCol," in the ",rPM$ndfName,
" data.frame are a mix of numbers and characters.\n",
" They must be all digits for for FIPS codes or characters for Seer Registry Abbreviations.")
stop(xmsg, call.=FALSE)
}
}
row.names(dataMapDF) <- dataMapDF$ID
rPM$dataMapDF <- dataMapDF
rPM$idMode <- idMode
rPM$BK0.dataMapDF <- dataMapDF
stMatch <- match(dataMapDF$stID,StateListFull)
if (debug) {
cat("stMatch Z-2899 :",paste0(stMatch,collapse=", "),"\n")
}
if (any(is.na(stMatch))) {
ErrFnd <- TRUE
MisList <- dataMapDF[is.na(stMatch),"ID"]
xmsg <- paste0("***046 The following ID values are not valid FIPs codes. Check the first two digits for the proper state codes:\n",
paste0(MisList, collapse=", "))
stop(xmsg, call.=FALSE)
}
stMatch <- match(dataMapDF$stID, states_data$stID)
if (any(is.na(stMatch))) {
DropList <- is.na(stMatch)
dataMapDF[DropList,"good"] <- FALSE
dataListData <- dataMapDF$ID
}
dataMapDF$rgID <- as.character(states_data[stMatch,"rgID"])
StateListData <- unique(dataMapDF$stID)
rPM$dataMapDF <- dataMapDF
rPM$StateListData <- StateListData
rPM$BK1.dataMapDF <- dataMapDF
if (debug) {
cat("Check if hs99, co99 or tr99 datasets need loading. Z-2974 idMode:",idMode,
" idGroup:",idGroup," loadDetails:",loadDetails,"\n")
}
hs99_proj <- NULL
hs99_data <- NULL
HSAListAll <- NA
HSAListData <- NA
co99_proj <- NULL
co99_data <- NULL
CountyListAll <- NA
coListData <- NA
tr99_proj <- NULL
tr99_data <- NULL
TractListAll <- NA
trListData <- NA
if (loadDetails) {
if (censusYear == "2000") {
cY = ""
DSext ="_d00"
} else {
cY = "2010"
DSext ="_d10"
}
hsDSList <- data.frame(DSN=character(), Pkg=character(), stringsAsFactors=FALSE)
coDSList <- data.frame(DSN=character(), Pkg=character(), stringsAsFactors=FALSE)
trDSList <- data.frame(DSN=character(), Pkg=character(), stringsAsFactors=FALSE)
for (stID in StateListData) {
wDSN2 <- paste0("hs",stID,"_d00")
wDSN <- paste0("co",stID,"_d00")
wPkg <- "SeerMapper"
if (censusYear == "2010") {
if (states_data[stID,"change10"]) {
wDSN2 <- paste0("hs",stID,"_d10")
wDSN <- paste0("co",stID,"_d10")
}
}
wEnHs <- data.frame(DSN=wDSN2,Pkg="SeerMapper",stringsAsFactors=FALSE)
wEnCo <- data.frame(DSN=wDSN,Pkg="SeerMapper",stringsAsFactors=FALSE)
hsDSList <- rbind(hsDSList,wEnHs)
coDSList <- rbind(coDSList,wEnCo)
stLoc <- states_data[stID,"loc"]
if(packageVersion("SeerMapperRegs")>="1.2.2" & packageVersion("SeerMapper2010Regs")>="1.2.2"){
stLoc <- states_data[stID,"loc2"]
states_data$loc<-stLoc
}else{
warning("The version of the data packages is older than 1.2.2.")
}
wDSN <- paste0("tr",stID,DSext)
wPkg <- paste0("SeerMapper",cY,stLoc)
wEnTr <- data.frame(DSN=wDSN,Pkg=wPkg,stringsAsFactors=FALSE)
trDSList <- rbind(trDSList,wEnTr)
}
wPkg <- unique(c(trDSList$Pkg,"SeerMapper"))
rPM$loadedDataSetList <- data(package=wPkg)$results[,"Item"]
hs99_proj <- loadBoundary2(rPM,hsDSList)
xM <- match(hs99_proj@data$ID, hs99_mapr$HSAID)
if (!is.null(rPM$CRSproj4)) {
hs99_proj <- spTransform(hs99_proj,rPM$CRSproj4)
c_XY<-t(sapply(slot(hs99_proj,"polygons"), function(x) c(x@ID,x@labpt[1],x@labpt[2])))
colnames(c_XY)<-c("ID","c_X","c_Y")
hs99_mapr_xM<-hs99_mapr[xM,]
c_XY_match<-match(hs99_mapr_xM$ID,c_XY[,"ID"])
if(censusYear=="2000"){
hs99_mapr_xM[,c("c_X_00","c_Y_00")]<-c_XY[c_XY_match,c("c_X","c_Y")]
}else if(censusYear=="2010"){
hs99_mapr_xM[,c("c_X_10","c_Y_10")]<-c_XY[c_XY_match,c("c_X","c_Y")]
}
hs99_mapr[xM,]<-hs99_mapr_xM
}
hs99_data <- hs99_proj@data
hs99_data$HSAID <- hs99_data$ID
hs99_data$HSA_Name <- hs99_mapr[xM,"HSA_Name"]
hs99_data$stID <- hs99_mapr[xM,"stID"]
hs99_data$saID <- hs99_mapr[xM,"saID"]
hs99_data$stcoID <- NA
hs99_data$stcotrID <- NA
MV$hs99_proj <- hs99_proj
MV$hs99_data <- hs99_data
HSAListAll <- hs99_data$HSAID
MV$HSAListAll <- HSAListAll
HSAListData <- unique(dataMapDF$HSAID)
MV$HSAListData <- HSAListData
if (idMode == 5) {
data_proj <- hs99_proj
data_data <- hs99_data
CountyListAll <- NULL
coListData <- NULL
TractListAll <- NULL
trListData <- NULL
} else {
co99_proj <- loadBoundary2(rPM, coDSList)
xM <- match(co99_proj@data$ID, co99_mapr$stcoID)
if (!is.null(rPM$CRSproj4)) {
co99_proj <- spTransform(co99_proj,rPM$CRSproj4)
c_XY<-t(sapply(slot(co99_proj,"polygons"), function(x) c(x@ID,x@labpt[1],x@labpt[2])))
colnames(c_XY)<-c("ID","c_X","c_Y")
co99_mapr_xM<-co99_mapr[xM,]
c_XY_match<-match(co99_mapr_xM$ID,c_XY[,"ID"])
if(censusYear=="2000"){
co99_mapr_xM[,c("c_X_00","c_Y_00")]<-c_XY[c_XY_match,c("c_X","c_Y")]
}else if(censusYear=="2010"){
co99_mapr_xM[,c("c_X_10","c_Y_10")]<-c_XY[c_XY_match,c("c_X","c_Y")]
}
co99_mapr[xM,]<-co99_mapr_xM
}
co99_data <- co99_proj@data
co99_data$stcoID <- co99_data$ID
co99_data$stID <- stringr::str_sub(co99_data$stcoID,1,2)
co99_data$coName <- co99_mapr[xM,"coName"]
co99_data$saID <- co99_mapr[xM,"saID"]
co99_data$stcotrID <- NA
CountyListAll <- co99_data$stcoID
coListData <- unique(dataMapDF$stcoID)
if (idMode == 2) {
data_proj <- co99_proj
data_data <- co99_data
TractListAll <- NULL
trListData <- NULL
} else {
if (idMode == 3) {
loadNSPkg <- loadedNamespaces()
missingPkg <- is.na(match(trDSList$Pkg, loadNSPkg))
if (any(missingPkg)) {
MissingList <- trDSList$Pkg[missingPkg]
ErrFnd <- TRUE
xmsg <- paste0("***198 The following supplemental SeerMapper Census Tract boundary packages are missing and must be installed and loaded:")
warning(xmsg, call.=FALSE)
xmsg <- paste0("***199 Missing:",paste0(MissingList,collapse=", "),"\n")
stop(xmsg, call.=FALSE)
rm(MissingList)
}
if (ErrFnd) stop()
tr99_proj <- loadBoundary2(rPM, trDSList )
if (!is.null(rPM$CRSproj4)) tr99_proj <- spTransform(tr99_proj,rPM$CRSproj4)
tr99_proj@data$ID <- as.character(row.names(tr99_proj))
tr99_data <- tr99_proj@data
tr99_data$stID <- as.character(stringr::str_sub(tr99_data$ID,1,2))
tr99_data$stcoID <- as.character(stringr::str_sub(tr99_data$ID,1,5))
tr99_data$stcotrID <- tr99_data$ID
tr99_data$saID <- as.character(co99_mapr[tr99_data$stcoID,"saID"])
trMatch <- match(tr99_data$stID,StateListAll)
TractListAll <- tr99_data[!is.na(trMatch),"stcotrID"]
data_data <- tr99_data
data_proj <- tr99_proj
dataMapDF$saID <- tr99_data[dataMapDF$ID,"saID"]
TractListAll <- tr99_data$stcotrID
trListData <- unique(dataMapDF$stcotrID)
}
}
}
}
rPM$BK2.dataMapDF <- dataMapDF
dataListAll <- row.names(data_proj)
dataListData <- dataMapDF$ID
MV$data_proj <- data_proj
MV$data_data <- data_data
MV$dataListAll <- dataListAll
rPM$dataListAll <- dataListAll
MV$dataListData <- dataListData
rPM$dataListData <- dataListData
MV$hs99_proj <- hs99_proj
MV$hs99_data <- hs99_data
MV$HSAListAll <- HSAListAll
rPM$HSAListAll <- HSAListAll
HSAListData <- unique(dataMapDF$HSAID)
MV$HSAListData <- HSAListData
rPM$HSAListData <- HSAListData
MV$co99_proj <- co99_proj
MV$co99_data <- co99_data
MV$CountyListAll <- CountyListAll
rPM$CountyListAll <- CountyListAll
coListData <- unique(dataMapDF$stcoID)
MV$coListData <- coListData
rPM$coListData <- coListData
MV$tr99_proj <- tr99_proj
MV$tr99_data <- tr99_data
MV$TractListAll <- TractListAll
rPM$TractListAll <- TractListAll
trListData <- unique(dataMapDF$stcotrID)
MV$trListData <- trListData
rPM$trListData <- trListData
rPM$dataMapDF <- dataMapDF
rPM$idMode <- idMode
rPM$Backup.dataMapDF <- dataMapDF
rPM <- SM_ValID(rPM,MV)
clipReset <- FALSE
clipTo <- rPM$clipTo
clipToNum <- rPM$clipToNum
if (clipTo == "HSA" && ( idMode == 1 || idMode == 5 || idMode == 4)) {
clipTo = "DATA"
clipToNum = 2
if (idMode != 5) clipReset <- TRUE
}
if (clipTo == "SEER" && ( idMode == 1 || idMode == 4)) {
clipTo = "DATA"
clipToNum = 2
if (idMode != 4) clipReset <- TRUE
}
if (clipTo == "STATE" && ( idMode == 1 )) {
clipTo = "DATA"
clipToNum = 2
}
if (clipReset) {
xmsg <- paste0("***096 The clipTo value specifies a geographic level lower than the data level. The clipTo value set to 'DATA'.\n")
warning(xmsg, call.=FALSE)
}
rPM$clipTo <- clipTo
rPM$clipToNum <- clipToNum
dataMapDF <- rPM$dataMapDF
dataListData <- dataMapDF$ID
RegionListData <- unique(dataMapDF$rgID)
StateListData <- unique(dataMapDF$stID)
SeerRegListData <- sort(unique(dataMapDF$saID))
HSAListData <- unique(dataMapDF$HSAID)
CountyListData <- unique(dataMapDF$stcoID)
TractListData <- unique(dataMapDF$stcotrID)
MV$dataListData <- dataListData
MV$RegionListData <- RegionListData
MV$StateListData <- StateListData
MV$SeerRegListData <- SeerRegListData
MV$HSAListData <- HSAListData
MV$CountyListData <- CountyListData
MV$TractListData <- TractListData
rPM <- SM_SetDef(rPM)
MV <- SM_Impl_B(rPM, MV)
xRes <- SM_box_sel(rPM, MV)
rPM <- xRes$rPM
MV <- xRes$MV
return(list(rPM=rPM,MV=MV))
}
SM_ValID <- function(rPM, MV) {
debug <- rPM$debug
dataMapDF <- rPM$dataMapDF
dataMapDF[is.na(dataMapDF$data),"good"] <- FALSE
dataMapDF[is.na(dataMapDF$ID),"good"] <- FALSE
idListData <- dataMapDF$ID
dupList <- duplicated(idListData)
if(any(dupList)) {
xmsg <- paste0("***202 The ",rPM$ndfName," data.frame has duplicate rows with the same location IDs. The duplicate rows will be removed.")
warning(xmsg, call.=FALSE)
dPos <- dataMapDF[dupList,"rSeq"]
idL <- idListData[dupList]
xlines <- paste0(formatC(dPos,width=5,)," ",stringr::str_sub(paste0(" ",idL),-5,-1),"\n")
xlines <- c(" row
xmsg <- paste0("***204 The duplicate IDs are:")
warning(xmsg, call.=FALSE)
warning(xlines, call.=FALSE)
dataMapDF[dupList,"good"] <- FALSE
}
areaMatch <- match(MV$dataListData, MV$dataListAll)
areaMatchNAs <- is.na(areaMatch)
if (any(areaMatchNAs)) {
areaMissing <- MV$dataListData[areaMatchNAs]
xmsg <- paste0("***290 The following area(s) in the data do not match the list of boundaries:")
ymsg <- paste0("***291 >",paste0(areaMissing,collapse=", "))
warning(xmsg, call.=FALSE)
warning(ymsg, call.=FALSE)
zmsg <- paste0("***292 Please check to make sure your data matches the 20",rPM$cYear, " census area identifiers and boundaries.")
warning(zmsg, call.=FALSE)
dataMapDF[areaMatchNAs,"good"] <- FALSE
}
dataMapDF <- dataMapDF[dataMapDF$good,]
rPM$dataMapDF <- dataMapDF
rPM$dataListData <- dataMapDF$ID
rPM$BK3.dataMapDF <- dataMapDF
if (debug) {
print(str(dataMapDF))
print(head(dataMapDF,10))
print(tail(dataMapDF,10))
}
lenDataMapDF <- dim(dataMapDF)[1]
if (lenDataMapDF <= 0 ) {
xmsg <- paste0("***200 After cleaning up the ",rPM$ndfName," data.frame to remove detected errors, there are no rows of data to process.")
stop(xmsg)
}
return(rPM)
}
SM_SetDef <- function(rPM) {
debug <- rPM$debug
idMode <- rPM$idMode
if (!rPM$regionB_caller) {
rPM$regionB <- switch( idMode,
"NONE",
"NONE",
"NONE",
"NONE",
"NONE"
)
}
if (!rPM$stateB_caller) {
rPM$stateB <- switch( idMode,
"ALL",
"NONE",
"NONE",
"NONE",
"NONE"
)
}
if (!rPM$seerB_caller) {
rPM$seerB <- switch( idMode,
"NONE",
"NONE",
"NONE",
"DATA",
"NONE"
)
}
if (!rPM$hsaB_caller) {
rPM$hsaB <- switch( idMode,
"NONE",
"NONE",
"NONE",
"NONE",
"DATA"
)
}
if (!rPM$countyB_caller) {
rPM$countyB <- switch( idMode,
"NONE",
"DATA",
"NONE",
"NONE",
"NONE"
)
}
if (!rPM$tractB_caller) {
rPM$tractB <- switch( idMode,
"NONE",
"NONE",
"DATA",
"NONE",
"NONE"
)
}
if (!rPM$clipTo_caller) {
rPM$clipTo <- "NONE"
rPM$clipToNum <- 1
}
if (!rPM$dataBCol_caller) {
rPM$dataBCol <- switch(idMode,
rPM$ColorB_O_State,
rPM$ColorB_O_County,
rPM$ColorB_O_Tract,
rPM$ColorB_O_Seer,
rPM$ColorB_O_Hsa,
rPM$ColorB_O_Tract
)
}
return(rPM)
}
SM_Impl_B <- function(rPM, MV) {
debug <- rPM$debug
GetIDListByrgID <- function(xx_data, LrgLD) {
xM <- !is.na(match(xx_data$rgID, LrgLD))
PList <- xx_data[xM,"ID"]
return (PList)
}
GetIDListBystID <- function(xx_data, LstLD) {
xM <- !is.na(match(xx_data$stID, LstLD))
PList <- xx_data[xM,"ID"]
return (PList)
}
GetIDListBysaID <- function(xx_data, LsaLD) {
xM <- !is.na(match(xx_data$saID, LsaLD))
PList <- xx_data[xM,"ID"]
return (PList)
}
GetIDListByhsID <- function(xx_data, LhsLD) {
xM <- !is.na(match(xx_data$HSAID, LhsLD))
PList <- xx_data[xM,"ID"]
return (PList)
}
GetIDListBystcoID <- function(xx_data, LstcoLD) {
xM <- !is.na(match(xx_data$stcoID, LstcoLD))
PList <- xx_data[xM,"ID"]
return (PList)
}
AddIDsBysaID <- function(xx_data, LsaLD, xxxLD) {
xM <- !is.na(match(xx_data$saID, LsaLD))
PList <- sort(unique(c(xx_data[xM,"ID"],xxxLD)))
return (PList)
}
AddIDsByhsID <- function(xx_data, LhsLD, xxxLD) {
xM <- !is.na(match(xx_data$HSAID, LhsLD))
PList <- sort(unique(c(xx_data[xM,"ID"],xxxLD)))
return (PList)
}
AddIDsBycoID <- function(xx_data, LstcoLD, xxxLD) {
xM <- !is.na(match(xx_data$stcoID, LstcoLD))
PList <- sort(unique(c(xx_data[xM,"ID"],xxxLD)))
return (PList)
}
MV$dataPList <- MV$dataListData
MV$regionPList <- switch(rPM$regionB,
NONE = NULL,
DATA = MV$RegionListData,
ALL = MV$RegionListAll,
NULL
)
MV$statePList <- switch(rPM$stateB,
NONE = NULL,
DATA = MV$StateListData,
REGION = GetIDListByrgID(MV$states_data,MV$RegionListData),
ALL = MV$StateListAll,
NULL
)
MV$seerPList <- switch(rPM$seerB,
NONE = NULL,
DATA = MV$SeerRegListData,
STATE = GetIDListBystID(MV$SeerRegs_data,MV$StateListData),
REGION = GetIDListByrgID(MV$SeerRegs_data,MV$RegionListData),
ALL = MV$SeerRegListAll,
NULL
)
idMode <- rPM$idMode
if (idMode == 1) {
if (rPM$stateB == "DATA" && rPM$seerB == "ALL") {
MV$seerPList <- GetIDListBystID(MV$SeerRegs_data,MV$StateListData)
}
if (rPM$stateB == "NONE" && rPM$seerB == "ALL") {
MV$seerPList <- GetIDListBystID(MV$SeerRegs_data,MV$StateListData)
}
}
if (idMode == 5 || idMode == 3 || idMode == 2 ) {
MV$hsaPList <- switch(rPM$hsaB,
NONE = NULL,
DATA = MV$HSAListData,
SEER = AddIDsBysaID(MV$hs99_data,MV$SeerRegListData,MV$HSAListData),
STATE = GetIDListBystID(MV$hs99_data,MV$StateListData),
NULL
)
}
if (idMode == 2 || idMode == 3) {
MV$countyPList <- switch(rPM$countyB,
NONE = NULL,
DATA = MV$CountyListData,
HSA = GetIDListByhsID(MV$co99_data,MV$HSAListData,MV$CountyListData),
SEER = AddIDsBysaID(MV$co99_data,MV$SeerRegListData,MV$CountyListData),
STATE = GetIDListBystID(MV$co99_data,MV$StateListData),
NULL
)
}
if (idMode == 3) {
MV$tractPList <- switch(rPM$tractB,
NONE = NULL,
DATA = MV$TractListData,
COUNTY= GetIDListBystcoID(MV$tr99_data,MV$CountyListData),
HSA = GetIDListByhsID(MV$tr99_data,MV$HSAListData,MV$TractListData),
SEER = AddIDsBysaID(MV$tr99_data,MV$SeerRegListData,MV$TractListData),
STATE = GetIDListBystID(MV$tr99_data,MV$StateListData),
NULL
)
}
if (debug) {
cat("setup up proj_data and proj_mapped for states and seer Z-4071 END of SM_Impl_B","\n")
cat("idMode:",rPM$idMode," regionB:",rPM$regionB," stateB:",rPM$stateB, " seerB:",rPM$seerB,
" hsaB:",rPM$hsaB, " countyB:",rPM$countyB," tractB:",rPM$tractB,
" fillTo:",rPM$fillTo, " dataMapDF Size:",dim(rPM$dataMapDF),"\n")
cat("dataPList :",length(MV$dataPList) ," ",paste0(MV$dataPList ,collapse=", "),"\n")
if (!is.null(MV$regionPList)) {
cat("regionPList :",length(MV$regionPList)," ",paste0(MV$regionPList,collapse=", "),"\n")
}
if (!is.null(MV$statePList)) {
cat("statePList :",length(MV$statePList) ," ",paste0(MV$statePList ,collapse=", "),"\n")
}
if (!is.null(MV$seerPList)) {
cat("seerPList :",length(MV$seerPList) ," ",paste0(MV$seerPList ,collapse=", "),"\n")
}
if (!is.null(MV$hsaPList)) {
cat("hsaPList :",length(MV$hsaPList) ," ",paste0(MV$hdaPList ,collapse=", "),"\n")
}
if (!is.null(MV$countyPList)){
cat("countyPList :",length(MV$countyPList)," ",paste0(MV$countyPList,collapse=", "),"\n")
}
if (!is.null(MV$tractPList)){
cat("tractPList :",length(MV$tractPList) ," ",paste0(MV$tractPList ,collapse=", "),"\n")
}
}
return(MV)
}
SM_box_sel <- function(rPM, MV) {
debug <- rPM$debug
idMode <- rPM$idMode
dataPList <- MV$dataPList
ErrFnd <- FALSE
dataMapDF <- rPM$dataMapDF
if (debug) {
cat("...PList, proj, and Boxes Z-4143 :", "\n")
cat("idMode :", idMode, "\n")
cat("dataPList :", dataPList, "\n")
}
data_proj_sel <- MV$data_proj
data_data_sel <- MV$data_data
if (!is.null(dataPList) && !any(is.na(dataPList))) {
data_proj_sel <- data_proj_sel[dataPList,]
data_data_sel <- data_data_sel[dataPList,]
data_box <- bbox(data_proj_sel)
} else {
if (!is.null(dataPList)) {
xmsg <- paste0("***380 Internal Error - dataPList contains an NA in list:", paste0(dataPList,collapse=", ") )
} else {
xmsg <- paste0("***381 Internal Error - dataPList does not exist.")
}
stop(xmsg, call.=FALSE)
}
MV$data_proj_sel <- data_proj_sel
MV$data_data_sel <- data_data_sel
data_box <- bbox(data_proj_sel)
tr_box <- data_box
co_box <- data_box
hs_box <- data_box
seer_box <- data_box
states_box <- data_box
regions_box <- data_box
tr_box_c <- data_box
Co_box_c <- data_box
hs_box_c <- data_box
sa_box_c <- data_box
st_box_c <- data_box
rg_box_c <- data_box
if (debug) {
cat("plot size Z-4202 - data_box:", data_box, "\n")
cat("regionB:",rPM$regionB," stateB:",rPM$stateB," seerB:",rPM$seerB," hsaB:",rPM$hsaB," countyB:",rPM$countyB," tractB:",rPM$tractB,"\n")
cat("regionPList-len :", length(MV$regionPList), " list:", MV$regionPList, "\n")
cat("statePList-len :", length(MV$statePList), " list:", MV$statePList, "\n")
cat("seerPList-len :", length(MV$seerPList), " list:", MV$seerPList, "\n")
cat("hsaPList-len :", length(MV$hsaPList), " list:", MV$hsaPList, "\n")
cat("countyPList-len :", length(MV$countyPList), " list:", MV$countyPList, "\n")
cat("tractPList-len :", length(MV$tractPList), " list:", MV$tractPList, "\n")
cat("rg_proj_sel-len :", length(MV$rg_proj_sel), "\n")
cat("states_proj-len :", length(MV$states_proj), "\n")
cat("SeerRegs_proj-len:", length(MV$SeerRegs_proj), "\n")
cat("hs99_proj-len :", length(MV$hs99_proj), "\n")
cat("co99_proj-len :", length(MV$co99_proj), "\n")
cat("tr99_proj-len :", length(MV$tr99_proj), "\n")
}
rg_proj_sel <- MV$regions_proj
regionPList <- MV$regionPList
rgGO <- FALSE
if (!is.null(regionPList)) {
if (!any(is.na(regionPList))) {
rg_proj_sel <- rg_proj_sel[regionPList,]
regions_box <- bbox(rg_proj_sel)
rgGO <- TRUE
rg_box_c <- bbox(rg_proj_sel[unique(dataMapDF$rgID),])
} else {
xmsg <- paste0("***382 Internal Error - regionPList contains a NA in list:",
paste0(regionPList,collapse=", "))
stop (xmsg,call.=FALSE)
regionPList <- NULL
}
} else {
ErrFnd <- FALSE
rg_proj_sel <- NULL
}
MV$rg_proj_sel <- rg_proj_sel
MV$regionPList <- regionPList
MV$rgGO <- rgGO
st_proj_sel <- MV$states_proj
statePList <- MV$statePList
stGO <- FALSE
if (!is.null(statePList)) {
if (!any(is.na(statePList))) {
st_proj_sel <- st_proj_sel[statePList,]
states_box <- bbox(st_proj_sel)
stGO <- TRUE
} else {
xmsg <- paste0("***384 Internal Error - statePList contains a NA in list:",paste0(statePList,collapse=", "))
stop (xmsg,call.=FALSE)
statePList <- NULL
}
} else {
ErrFnd <- FALSE
st_proj_sel <- NULL
}
MV$st_proj_sel <- st_proj_sel
MV$statePList <- statePList
MV$stGO <- stGO
sa_proj_sel <- MV$SeerRegs_proj
seerPList <- MV$seerPList
saGO <- FALSE
if (!is.null(seerPList)) {
if (!any(is.na(seerPList))) {
sa_proj_sel <- sa_proj_sel[seerPList,]
seer_box <- bbox(sa_proj_sel)
saGO <- TRUE
} else {
xmsg <- paste0("***386 Internal Error - seerPList contains a NA in list:",paste0(seerPList,collapse=", "))
stop(xmsg,call.=FALSE)
seerPList <- NULL
}
} else {
ErrFnd <- FALSE
sa_proj_sel <- NULL
}
MV$sa_proj_sel <- sa_proj_sel
MV$seerPList <- seerPList
MV$saGO <- saGO
hs_proj_sel <- MV$hs99_proj
hsaPList <- MV$hsaPList
hsGO <- FALSE
if (!is.null(hsaPList)) {
if (!any(is.na(hsaPList))) {
hs_proj_sel <- hs_proj_sel[hsaPList,]
hs_box <- bbox(hs_proj_sel)
hsGO <- TRUE
} else {
xmsg <- paste0("***389 Internal Error - hsaPList contains a NA in list:",
paste0(hsaPList,collapse=", "))
stop(xmsg,call.=FALSE)
hsaPList <- NULL
}
} else {
ErrFnd <- FALSE
hs_proj_sel <- NULL
}
MV$hs_proj_sel <- hs_proj_sel
MV$hsaPList <- hsaPList
MV$hsGO <- hsGO
co_proj_sel <- MV$co99_proj
countyPList <- MV$countyPList
coGO <- FALSE
if (!is.null(countyPList)) {
if (!any(is.na(countyPList))) {
co_proj_sel <- co_proj_sel[countyPList,]
co_box <- bbox(co_proj_sel)
coGO <- TRUE
} else {
xmsg <- paste0("***387 Internal Error - countyPList contains a NA in list:",
paste0(countyPList,collapse=", "))
stop(xmsg,call.=FALSE)
countyPList <- NULL
}
} else {
ErrFnd <- FALSE
co_proj_sel <- NULL
}
MV$co_proj_sel <- co_proj_sel
MV$countyPList <- countyPList
MV$coGO <- coGO
tr_proj_sel <- MV$tr99_proj
tractPList <- MV$tractPList
trGO <- FALSE
if (!is.null(tractPList)) {
if (!any(is.na(tractPList))) {
tr_proj_sel <- tr_proj_sel[tractPList,]
tr_box <- bbox(tr_proj_sel)
trGO <- TRUE
} else {
xmsg <- paste0("***388 Internal Error - tractPList contains a NA in list:",
paste0(tractPList,collapse=", "))
stop(xmsg,call.=FALSE)
tractPList <- NULL
}
} else {
ErrFnd <- FALSE
tr_proj_sel <- NULL
}
MV$tr_proj_sel <- tr_proj_sel
MV$tractPList <- tractPList
MV$trGO <- trGO
xwl <- c( NA, NA)
ywl <- c( NA, NA)
if (debug) {
cat(" Z-4445 \n")
cat("data_box :",data_box,"\n")
cat("regions_box:",regions_box,"\n")
cat("states_box :",states_box,"\n")
cat("seer_box :",seer_box,"\n")
cat("hs_box :",hs_box,"\n")
cat("co_box :",co_box,"\n")
cat("tr_box :",tr_box,"\n")
}
rPM$clipRes <- switch(rPM$clipTo,
NONE = c(T,T,T,T,T,T,T,T,T,T,T,T,T,T),
DATA = c(T,T,F,F,F,F,F,F,F,F,F,F,F,F),
COUNTY = c(T,T,F,F,F,F,F,F,F,F,T,T,T,T),
HSA = c(T,T,F,F,F,F,F,F,T,T,T,T,T,T),
SEER = c(T,T,F,F,F,F,T,T,T,T,T,T,T,T),
STATE = c(T,T,F,F,T,T,T,T,T,T,T,T,T,T),
NULL
)
xwl <- c(data_box[1,],regions_box[1,],states_box[1,],seer_box[1,],hs_box[1,],co_box[1,],tr_box[1,])
ywl <- c(data_box[2,],regions_box[2,],states_box[2,],seer_box[2,],hs_box[2,],co_box[2,],tr_box[2,])
if (rPM$clipToNum > 0) {
xwl <- xwl[rPM$clipRes]
ywl <- ywl[rPM$clipRes]
} else {
xwl <- c(data_box[1,],regions_box[1,],states_box[1,],seer_box[1,],hs_box[1,],co_box[1,],tr_box[1,])
ywl <- c(data_box[2,],regions_box[2,],states_box[2,],seer_box[2,],hs_box[2,],co_box[2,],tr_box[2,])
}
xlPlot <- range(xwl)
ylPlot <- range(ywl)
xyBox <- matrix(c(xlPlot,ylPlot), ncol=2, byrow=TRUE)
colnames(xyBox) <- c("min","max")
row.names(xyBox) <- c("x","y")
MV$xyBox <- xyBox
MV$xlPlot <- xlPlot
MV$ylPlot <- ylPlot
if (debug) {
cat("limits Z-4515 x:",xlPlot," y:",ylPlot,"\n")
}
AspRatio <- (xlPlot[2] - xlPlot[1]) / (ylPlot[2] - ylPlot[1])
rPM$AspRatio <- AspRatio
return(list(rPM=rPM, MV=MV))
}
SM_Categ <- function(rPM) {
FindDigits <- function (x) {
dig = 0
for (ind in c(nchar(x):1)) {
if (substr(x,ind,ind) != "0") {
dig = ind
break
}
}
if (dig > 0) {
for (jnd in c((ind-1):1)) {
if (substr(x,jnd,jnd) == ".") {
dig = dig - jnd
break
}
}
}
return(dig)
}
RateRound <- function(AllRateC, wInterv, wIntervDigits) {
hh <- length(AllRateC)
RMul <- 10^ wIntervDigits
AllRateC2 <- AllRateC * RMul
AllRateC1 <- AllRateC2
AllRateC1[1] <- floor(AllRateC1[1])
AllRateC1[hh] <- ceiling(AllRateC1[hh])
cR <- seq(1,hh)[-c(1,hh)]
AllRateC1[cR] <- round(AllRateC1[cR],0)
AllRateR <- AllRateC1/RMul
return(AllRateR)
}
RateLabel <- function(AllRateC,wIntervDigits) {
wD <- wIntervDigits
OpenFrame = "["
np = length(AllRateC)
wCat = rep("",np)
for (ind in c(2:np)) {
wCat[ind] = paste0(OpenFrame,formatC(AllRateC[ind-1],format='f',digits=wD),',',formatC(AllRateC[ind],format='f',digits=wD),']')
OpenFrame = '('
}
return(wCat)
}
RateQuan <- function(brkpt, data) {
wRange <- range(data)
wQ <- quantile(data,probs=brkpt)
wQ[1] <- wRange[1]
return(wQ)
}
RateCutAdj <- function(brkpt) {
bp = brkpt
np <- length(bp)
wCat <- rep("",np)
modp <- FALSE
xp0 <- round( diff(bp), digits = 10)
xp <- unique(sort(xp0))
xp <- xp[xp>0]
mininterval <- xp[1]/5
Interv <<- 0.01
if (Interv > mininterval) Interv <<- mininterval
wVal = Interv
for (ind in c(0:9)) {
if (wVal >= 1) break
wVal = wVal * 10
}
IntervDigits <<- ind
NextValue = bp[1]
jndList = seq(2,np,by = 1)
for (jnd in jndList) {
NextValue = NextValue + Interv
if (NextValue > bp[jnd] ) {
bp[jnd] <- NextValue
modp <- TRUE
}
if (NextValue < bp[jnd] ) break
}
indList = seq(np-1, 1, by = -1)
NextValue = bp[np]
for (ind in indList) {
NextValue = NextValue - Interv
if (NextValue >= bp[ind]) break
if (NextValue < bp[ind]) {
bp[ind] = NextValue
modp <- TRUE
}
}
numData <- table(bp)[table(bp)>1] - 1
np2 <- length(numData)
if (np2 > 0) {
dupData <- as.numeric(names(numData))
startData <- match(dupData, bp)
for (ind in c(1:np2)) {
sD <- startData[ind]
nD <- numData[ind]
vD <- bp[startData[ind]]
vFlag <- TRUE
aD <- seq((nD/2 * -Interv), (nD/2 * Interv), by=Interv)
for (jnd in c(0:nD)) {
bp[sD+jnd] <- bp[sD+jnd] + aD[jnd+1]
modp <- TRUE
}
}
}
bpList <- list(before=brkpt, after=bp, Intv = Interv, IntvD = IntervDigits, minIntv = mininterval)
return(bpList)
}
debug <- rPM$debug
debugFlag <- rPM$debugFlag
numberTestRegExpr <- rPM$numberTestRegExpr
dataMapDF <- rPM$dataMapDF
dataListData<- rPM$dataListData
categMode <- rPM$categMode
categ <- rPM$categ
wCateg <- rPM$wCateg
CatNumb <- rPM$CatNumb
brkPtDigits <- rPM$brkPtDigits
idMode <- rPM$idMode
mapData <- dataMapDF$data
if (is.factor(mapData)) {
mapData <- as.character(mapData)
}
naList <- is.na(mapData)
if (any(naList)) {
ErrFnd <- TRUE
BadList <- dataMapDF[naList,"ID"]
xmsg <- paste0("***060 The following data rows in column ",rPM$dataCol,
" of the ",rPM$ndrName,
" data.frame contains missing (NA) values and will not be mapped. Location IDs: ",
paste0(BadList,collapse=", "))
warning(xmsg, call.=FALSE)
dataMapDF <- dataMapDF[!naList,]
rPM$dataListData <- dataMapDF$ID
mapData <- dataMapDF$data
}
if (categMode == 4) {
mapData <- stringr::str_trim(as.character(mapData))
iC <- unique(mapData)
lenIC <- length(iC)
iR <- is.Color(mapData)
if (any(!iR)) {
badList <- unique(mapData[!iR])
ErrFnd <- TRUE
xmsg <- paste0("***065 Data in column ",rPM$dataCol," in ",rPM$ndfName,
" data.frame contains one or more values that are not a color and will be ignored.")
warning(xmsg, call.=FALSE)
xmsg <- paste0("***066 Bad Color value(s):",paste0(badList,collapse=", "))
warning(xmsg, call.=FALSE)
mapData[!iR] <- "white"
}
colorList <- unique(mapData)
colorListGood <- colorList != "white"
colorList <- colorList[colorListGood]
NumCList <- length(colorList)
if (NumCList > 11) {
xmsg <- paste0("***067 The dataCol (",rPM$dataCol,") contains ",NumCList,
" colors. It is recommended to limit the number of colors to 11.")
warning(xmsg, call.=FALSE)
}
CatNumb <- NumCList
rPM$CB_Rate_Mid2 <- colorList
} else {
if (!is.numeric(mapData)) {
if (is.character(mapData)) {
mapData <- stringr::str_trim(mapData)
mapData <- gsub(",","",mapData)
suppressWarnings( mapData <- as.numeric(mapData) )
mapDataNAs <- is.na(mapData)
if (any(mapDataNAs)) {
ErrFnd <- TRUE
BadList <- dataMapDF$ID[mapDataNAs]
xmsg <- paste0("***061 Some of the data values in the ",rPM$dataCol," column in the ",rPM$ndfName,
" data.frame are not numeric values. Sub-areas will not be mapped. Location IDs:",
paste0(BadList,collapse=", "))
warning(xmsg, call.=FALSE)
dataMapDF <- dataMapDF[!mapDataNAs,]
rPM$dataListData <- dataMapDF$ID
mapData <- dataMapDF$data
}
} else {
ErrFnd <- TRUE
xmsg <- paste0("***064 The data column ",rPM$dataCol," in ",rPM$ndfName,
" data.frame is not numeric or character type numeric data. Processing terminated.")
stop(xmsg)
}
} else {
ErrFnd <- FALSE
}
}
dataMapDF$data <- mapData
rPM$dataMapDF <- dataMapDF
rPM$dataListData <- dataListData
ErrFnd <- FALSE
CatRange <- range(mapData)
if (debug) {
cat("Calculating 'categ' and generate values. Z-5044 categ:",categ,"\n")
}
R.Cat <- categ
CatBase <- 1
catMaxNum <- rPM$palColorsMaxNum -1
if (categMode == 3) {
CatRange <- range(mapData)
CatBase <- CatRange[1]
CatDiff <- diff(CatRange) + 1
if (all(as.integer(mapData) == mapData)) {
if (CatDiff > catMaxNum) {
xmsg <- paste0("***267 The ",rPM$dataCol," column data are integer category values. ",
"The range of the values is greater than the maximum of ",
catMaxNum,". Reduce number of categories or select different palColors value.")
stop(xmsg, call.=FALSE)
}
} else {
xmsg <- paste0("***270 The categ call parameter is 'DATA'. The ",rPM$dataCol,
" column does not appear to contain integer values.")
stop(xmsg, call.=FALSE)
}
AllRateCutR <- NULL
AllRateCatR <- formatC(seq(CatRange[1],CatRange[2],by=1),format="f",digits=0)
CatNumb <- CatDiff
CB_Rate_Mid <- rev(RColorBrewer::brewer.pal(CatNumb,rPM$palColors))
rPM$CB_Rate_Mid <- CB_Rate_Mid
dataMapDF$cat <- dataMapDF$data - (CatBase - 1)
dataMapDF$col <- rPM$CB_Rate_Mid[as.integer(dataMapDF$cat)]
}
if (categMode == 2) {
if (any(!is.numeric(R.Cat))) {
xmsg <- paste0("***263 One or more values in the categ breakpoint list is not a number. The default of categ=5 will be used.")
warning (xmsg, call.=FALSE)
R.Cat <- 5
CatNumb <- 5
categMode <- 1
} else {
wRCat <- sort(unique(R.Cat))
if (length(categ) != length(wRCat)) {
xmsg <- paste0("***265 The categ call parameter contains a break point vector with duplicate values.",
" The duplicate values will be removed.")
warning(xmsg, call.=FALSE)
R.Cat <- wRCat
}
lCat <- length(wRCat)
if (lCat < 3 || lCat > catMaxNum) {
xmsg <- paste0("***266 The number of points in the categ call parameter list is out of range. It must be between 3 and ",catMaxNum,". The default of categ=5 will be used.")
warning(xmsg, call.=FALSE)
R.Cat <- 5
CatNumb <- 5
categMode <- 1
}
categ <- R.Cat
lCat <- length(R.Cat)
if (lCat > 1) {
AllRateQOrig <- R.Cat
AllRateQ <- c(-Inf, R.Cat, Inf)
CatNumb <- length(R.Cat) + 1
}
}
}
if (categMode == 1) {
CatNumb <- categ
xq <- seq(0,1,1/categ)
AllRateQ <- RateQuan(xq,mapData)
AllRateQOrig <- AllRateQ
rm(xq)
}
if (categMode == 1 || categMode == 2) {
AllRateCut <- RateCutAdj(AllRateQ)
Interv <- as.numeric(AllRateCut$Intv)
IntervDigits <- as.integer(AllRateCut$IntvD)
BrkPtLabs <- sapply(AllRateCut$after, function(u) formatC(u,format="f",digits=8))
BrkPtDigs <- sapply(BrkPtLabs,FindDigits)
BrkPtDigsMax <- max(BrkPtDigs)
BrkPtDigsRange <- range(BrkPtDigs)
if (BrkPtDigsMax < IntervDigits) IntervDigits = BrkPtDigsMax
if (debug) {
cat(" Original Cal. List (AllRateQ):\n ")
cat(AllRateCut$before,"\n")
cat(" Modified List ($after) :\n ")
cat(AllRateCut$after,"\n")
cat(" Interval Value ($Intv) :",Interv,"\n")
cat(" Interval Digits ($IntvD) :",IntervDigits,"\n")
cat(" Brk Pt Digits (parameter) :",brkPtDigits,"\n")
cat(" dim of dataMapDF :",dim(dataMapDF),"\n")
cat("\n")
}
RndDig <- IntervDigits
if (!is.null(brkPtDigits)) RndDig <- rPM$brkPtDigits
AllRateCutR <- RateRound(AllRateCut$after, Interv, RndDig)
AllRateCatR <- RateLabel(AllRateCutR,RndDig)
CB_Rate_Mid <- rev(RColorBrewer::brewer.pal(CatNumb,rPM$palColors))
rPM$CB_Rate_Mid <- CB_Rate_Mid
RTC <- cut(mapData,breaks=AllRateCutR,labels=FALSE,include.lowest=TRUE)
dataMapDF$cat <- RTC
dataMapDF$col <- rPM$CB_Rate_Mid[as.integer(dataMapDF$cat)]
}
if (categMode == 4) {
catColL <- sort(unique(mapData))
rPM$CB_Rate_Mid2 <- catColL
CatRange <- c(1,length(catColL))
catColCatM <- match(mapData,catColL)
dataMapDF$cat <- catColCatM
AllRateCutR <- NULL
AllRateCatR <- formatC(catColL,format="f",digits=0)
dataMapDF$cat <- match(mapData,catColL)
dataMapDF$col <- mapData
}
CatCount <- tabulate(dataMapDF$cat)
np <- length(AllRateCatR)
AllRateCatRw <- as.character(AllRateCatR[2:np])
AllRateCatRwCnt <- paste0(AllRateCatRw," <",CatCount,">")
AllRateCatRAdj <- AllRateCatRw
if (rPM$mLegend$lNoValue) {
AllRateCatRAdj[CatCount == 0] <- paste0(AllRateCatRAdj[CatCount==0]," NV")
}
if (debug) {
cat(" Category Labels (AllRateCatR):\n")
cat(" ",AllRateCatR,"\n")
cat(" Category Adj Labels (AllRateCatRAdj):\n")
cat(" ",AllRateCatRAdj,"\n")
cat(" Category Labels with counts (AllRateCatRwCnt):\n")
cat(" ",AllRateCatRwCnt,"\n")
cat("\n")
cat("Table of number of areas in each category:\n")
cat(c(1:length(CatCount)),"\n")
cat(CatCount,"\n")
cat("\n")
cat("dataMapDF$col variable- Z-5357 :\n",paste0(dataMapDF$col,collapse=", "),"\n")
print(str(dataMapDF))
print(dataMapDF[,c("ID","data","hData","h2Data","col","cat","hRes","h2Res")])
}
rPM$dataMapDF <- dataMapDF
rPM$CatR <- AllRateCatR
rPM$CatRAdj <- AllRateCatRAdj
rPM$CatRwCnt <- AllRateCatRwCnt
return(rPM)
}
SM_Mapper <- function(rPM, MV) {
debug <- rPM$debug
dataMapDF <- rPM$dataMapDF
dataLwd <- 0.75
tractLwd <- 0.75
countyLwd <- 1.0
hsaLwd <- 1.33
seerLwd <- 1.66
stateLwd <- 2.0
regionLwd <- 2.0
data_BCol <- rPM$ColorB_Data
Tract_BCol <- rPM$ColorB_O_Tract
County_BCol <- rPM$ColorB_O_County
HSA_BCol <- rPM$ColorB_O_Hsa
Seer_BCol <- rPM$ColorB_O_Seer
State_BCol <- rPM$ColorB_O_State
Region_BCol <- rPM$ColorB_O_Region
wData_proj <- MV$data_proj_sel
wData_data <- MV$data_data_sel
dataMapDF <- rPM$dataMapDF
wDataBCol <- rPM$dataBCol
wDataBCol_caller <- rPM$dataBCol_caller
wIdMode <- rPM$idMode
wDataID <- row.names(wData_proj)
vxLim <- MV$xlPlot
vyLim <- MV$ylPlot
if (debug) {
cat("Main plot - Z-5494 - Length wData_proj:", length(wData_proj)," length cols:",length(dataMapDF$col),"\n")
print("wData_data:")
cat("rgGO",MV$rgGO," regionPList:",MV$regionPList,"\n")
cat("stGO",MV$stGO," statePList:",MV$statePList, "\n")
cat("saGO",MV$saGO," seerPList:",MV$seerPList, "\n")
cat("hsGO",MV$hsGO," hsaPList:",MV$hsaPList, "\n")
cat("coGO",MV$coGO," countyPList:",MV$countyPList,"\n")
cat("trGO",MV$trGO," tractPList:",MV$tractPList, "\n")
}
par(mar=c(3.1, 1.1, 3.1, 1.1))
plot.new()
par(new=T)
plot(wData_proj,
col = wData_data$col,
den = NA,
border = NA,
xlim = vxLim, ylim = vyLim
)
IDList <- dataMapDF$ID
if (rPM$HatchFlag) {
Hk <- rPM$hatch
Hk$ID <- dataMapDF$ID
Hk$hRes <- dataMapDF$hRes
HIDList <- Hk$ID[Hk$hRes]
if (debug) {
cat("Hatching
cat("hatch:\n")
print(str(Hk))
}
xm <- match(wDataID,HIDList)
xmDo <- !is.na(xm)
hData_proj <- wData_proj[xmDo,]
par(new=TRUE)
plot(hData_proj,
density = Hk$hDen,
col = Hk$hCol,
lty = 1,
border = NA,
lwd = Hk$hLwd,
angle = Hk$hAngle,
xlim = vxLim, ylim = vyLim
)
}
if (rPM$Hatch2Flag) {
Hk <- rPM$hatch2
Hk$ID <- dataMapDF$ID
Hk$hRes <- dataMapDF$h2Res
HIDList <- Hk$ID[Hk$hRes]
if (debug) {
cat("Hatching requested Z-5609 - ", rPM$ndfName, "\n")
cat("hatch2:\n")
print(str(Hk))
}
xm <- match(wDataID,HIDList)
xmDo <- !is.na(xm)
hData_proj <- wData_proj[xmDo,]
par(new=TRUE)
plot(hData_proj,
density = Hk$hDen,
col = Hk$hCol,
lty = 1,
border = NA,
lwd = Hk$hLwd,
angle = Hk$hAngle,
xlim = vxLim, ylim = vyLim
)
}
if (MV$trGO) {
if (wIdMode == 3) {
if (wDataBCol_caller) Tract_BCol <- wDataBCol
tractLwd <- dataLwd
}
par(new=TRUE)
plot(MV$tr_proj_sel,
border = Tract_BCol,
col = NA,
lwd = tractLwd,
xlim = vxLim, ylim = vyLim
)
}
if (MV$coGO) {
if (wIdMode == 2) {
if (wDataBCol_caller) County_BCol <- wDataBCol
countyLwd <- dataLwd
}
par(new=TRUE)
plot(MV$co_proj_sel,
border = County_BCol,
col = NA,
lwd = countyLwd,
xlim = vxLim, ylim = vyLim
)
}
if (MV$hsGO) {
if (wIdMode == 5) {
if (wDataBCol_caller) HSA_BCol <- wDataBCol
hsaLwd <- dataLwd
}
par(new=TRUE)
plot(MV$hs_proj_sel,
border = HSA_BCol,
col = NA,
lwd = hsaLwd,
xlim = vxLim, ylim = vyLim
)
}
if (MV$saGO) {
if (wIdMode == 4) {
if (wDataBCol_caller) Seer_BCol <- wDataBCol
seerLwd <- dataLwd
}
par(new=TRUE)
plot(MV$sa_proj_sel,
border = Seer_BCol,
col = NA,
lwd = seerLwd,
xlim = vxLim, ylim = vyLim
)
}
if (MV$stGO) {
if (wIdMode == 1) {
if (wDataBCol_caller) State_BCol <- wDataBCol
stateLwd <- dataLwd
}
par(new=TRUE)
plot(MV$st_proj_sel,
border = State_BCol,
col = NA,
lwd = stateLwd,
xlim = vxLim, ylim = vyLim
)
}
if (MV$rgGO) {
par(new=TRUE)
plot(MV$rg_proj_sel,
border = Region_BCol,
col = NA,
lwd = regionLwd,
xlim = vxLim, ylim = vyLim
)
}
xyBox <- data.frame(min=numeric(),max=numeric())
xyBox <- rbind(xyBox,vxLim)
xyBox <- rbind(xyBox,vyLim)
colnames(xyBox) <- c("min","max")
row.names(xyBox) <- c("x","y")
invisible(xyBox)
}
SM_Legend <- function(rPM, MV) {
Lg <- rPM$mLegend
debug <- rPM$debug
wPin <- par("pin")
wMai <- par("mai")
BotRoom <- - (wMai[1] / wPin[2]) / 2
tempCex <- Lg$lSize * 2
tempPch <- Lg$lPch
if (debug) {
cat("Mapping legend Z-5809 \n"," tempCex :",tempCex," tempPch:",tempPch," CatNumb:",rPM$CatNumb,"\n")
print(str(Lg))
cat("CB_Rate_Mid:",rPM$CB_Rate_Mid,"\n")
}
if (Lg$lCounts) {
legend(Lg$lPosv, rPM$CatRwCnt[1:rPM$CatNumb],
ncol = Lg$lNumCols,
cex = Lg$lSize,
xpd = NA,
inset = c(0.01,BotRoom),
pt.bg = rPM$CB_Rate_Mid,
pt.cex= tempCex,
pch = tempPch
)
} else {
legend(Lg$lPosv, rPM$CatRAdj[1:rPM$CatNumb],
ncol = Lg$lNumCols,
cex = Lg$lSize,
inset = c(0.01,BotRoom),
xpd = NA,
pt.bg = rPM$CB_Rate_Mid,
pt.cex= tempCex,
pch = tempPch
)
}
}
SeerMapper2000 <- function(...) {
SeerMapper(censusYear="2000",...)
}
SeerMapper2010 <- function(...) {
SeerMapper(censusYear="2010",...)
}
SeerMapper.Version <- function() {return("SeerMapper V1.2.2 2019-07-31 03:04pm")}
SeerMapper <- function(ndf,
censusYear = NULL,
proj4 = NULL,
idCol = NULL,
dataCol = NULL,
categ = NULL,
mTitle = NULL,
mTitle.cex = NULL,
us48Only = NULL,
includePR = NULL,
regionB = NULL,
stateB = NULL,
seerB = NULL,
hsaB = NULL,
countyB = NULL,
tractB = NULL,
dataBCol = NULL,
fillTo = NULL,
clipTo = NULL,
hatch = NULL,
hatch2 = NULL,
mLegend = NULL,
brkPtDigits = NULL,
palColors = NULL,
debug = NULL
)
{
CheckColnn <- function(varName, msgNums, varValue, stDat, stDatName) {
xr <- list(Err = FALSE, colNum = as.integer(0), colName="")
wstname <- names(stDat)
wstMax <- dim(stDat)[2]
wstname <- c(wstname,seq(1:wstMax))
ErrFnd <- FALSE
if (is.numeric(varValue)) {
if (varValue < 1 || varValue > wstMax) {
ErrFnd <- TRUE
xmsg <- paste0("***",msgNums[1]," ",varName," parameter is out of range. It must be a column number between 1 and ",wstMax,".")
} else {
xr$colNum <- varValue
xr$colName <- wstname[varValue]
}
} else {
if (is.character(varValue)) {
varValue <- stringr::str_trim(varValue)
if (nchar(varValue) < 1) {
ErrFnd <- TRUE
xmsg <- paste0("***",msgNums[4]," ",varName," parameter is a character string, but is empty.")
} else {
xm <- match(varValue, wstname)
if (is.na(xm)) {
ErrFnd <- TRUE
xmsg <- paste0("***",msgNums[2]," ",varName," parameter is not a valid column name (",varValue,") in the ",stDatName," data.frame.")
} else {
if (xm > wstMax) { xm <- ( xm - wstMax) }
xr$colNum <- as.integer(xm)
xr$colName <- varValue
}
}
} else {
ErrFnd <- TRUE
xmsg <- paste0("***",msgNums[3]," ",
varName, " parameter is not the correct data type (",
typeof(varValue),"). Must be numeric or character.")
}
}
if (ErrFnd) {
xr$Err <- TRUE
warning(xmsg,call.=FALSE)
}
return(xr)
}
rPM <- SM_GlobInit()
rPM$debugFlag <- FALSE
rPM$debugFlag <- FALSE
debugFlag <- rPM$debugFlag
censusYear_def <- "2000"
if (!debugFlag) {
frml <- formals()
frmlNames <- names(formals())
if (length(frmlNames) == 1 && frmlNames[[1]] == "fun") {
debugFlag <- TRUE
}
if (!debugFlag) {
callVar <- as.list(match.call())[-1]
callVarNames <- names(callVar)
callVL <- frml
callVL[callVarNames] <- callVar[callVarNames]
callVarList <- as.list(callVL)
}
}
if (debugFlag) {
callVL <- list(ndf=I(ndf),
censusYear = censusYear_def,
proj4 = NULL,
idCol = "FIPS",
dataCol = "Rate",
categ = 5,
hatch = FALSE,
hatch2 = NULL,
mLegend = NULL,
regionB = "NONE",
stateB = "DATA",
seerB = "DATA",
hsaB = "NONE",
countyB = "NONE",
tractB = "NONE",
regions = FALSE,
fillTo = "NONE",
clipTo = "NONE",
dataBCol = NULL,
us48Only = FALSE,
includePR = FALSE,
mTitle = NULL,
mTitle.cex = NULL,
brkPtDigits= 2,
debug = NULL
)
callVL$ndfName <- "ndf"
callVarList <- callVL
}
ndfName <- callVarList$ndfName
callVarList$ndfName <- ndfName
rPM$ndfName <- ndfName
debug_def <- FALSE
if (is.null(debug)) {
debug <- debug_def
} else {
debug <- debug[[1]][1]
if (is.na(debug)) {
debug <- debug_def
}
}
callVarList$debug <- debug
rPM$debug <- debug
if (is.null(censusYear)) {
censusYear <- censusYear_def
} else {
censusYear <- censusYear[[1]][1]
if (is.na(censusYear)) {
censusYear <- censusYear_def
}
censusYear <- stringr::str_trim(toupper(censusYear))
if (!(censusYear == "2000" || censusYear == "2010")) {
ErrFnd <- TRUE
xmsg <- paste0("***010 The censusYear parameter is set to ",censusYear," and is invalid. It must be '2000' or '2010'.")
warning(xmsg, call.=FALSE)
censusYear <- censusYear_def
}
}
cYear <- stringr::str_sub(censusYear,-2,-1)
callVarList$censusYear <- censusYear
rPM$censusYear <- censusYear
rPM$cYear <- cYear
cY <- ""
if (censusYear != "2000") { cY <- censusYear }
rPM$cY <- cY
if (debug) {
cat("censusYear Z-6358 :",censusYear," cYear:",cYear," cY:",cY,"\n")
}
proj4_def <- NULL
CRSproj4 <- NULL
if (is.null(proj4)) {
proj4 <- proj4_def
} else {
proj4 <- proj4[[1]][1]
if (is.na(proj4)) {
proj4 <- proj4_def
} else {
proj4 <- stringr::str_trim(proj4)
}
}
if (!is.null(proj4)) {
res <- convertPROJ4(proj4)
if (class(res) == "CRS") {
CRSproj4 <- res
} else {
EffFnd = TRUE
CRSproj4 <- NULL
xmsg <- paste0("***909 Error on processing proj4 parameter. No user specified projection will be done.")
warning(xmsg,call.=FALSE)
}
}
callVarList$proj4 <- proj4
rPM$proj4 <- proj4
callVarList$CRSproj4 <- CRSproj4
rPM$CRSproj4 <- CRSproj4
if (debug) {
cat("proj 4 Z-6420 : proj4:",proj4,"\n")
if (!is.null(proj4)) print(CRSproj4)
}
categMode <- 0
CatNumb <- 0
categ_def <- 5
ErrFnd <- FALSE
if (is.null(categ)) {
categ <- categ_def
} else {
if (length(categ) == 0) {
ErrFnd <- TRUE
} else {
if (any(is.na(categ))) {
ErrFnd <- TRUE
}
}
if (ErrFnd) {
xmsg <- paste0("***250 The categ call parameter is missing, empty or contains NAs.",
" The default value of 5 will be used.")
warning(xmsg, call.=FALSE)
categ <- 5
}
}
if (!ErrFnd) {
ErrFnd <- FALSE
wCateg <- categ
repeat {
if (length(wCateg) == 1) {
wCateg <- wCateg[[1]][1]
if (is.character(wCateg)) {
wCateg <- stringr::str_trim(wCateg)
if (nchar(wCateg)>0) {
wCateg2 <- toupper(wCateg)
if (wCateg2 == "DATA") {
categMode <- 3
wCateg <- wCateg2
break
} else {
if (wCateg2 == "COLORS") {
categMode <- 4
wCateg <- wCateg2
break
} else {
suppressWarnings(wCateg2 <- as.numeric(wCateg))
if (is.na(wCateg2)) {
wCateg2 <- 0
xcmd <- paste0("wCateg2 <- ",wCateg)
iR <- try(eval(parse(text=xcmd)),TRUE)
if (class(iR) == "try-error") {
xmsg <- paste0("***252 The value entered for categ parameter is not valid : ",wCateg," The default of categ=5 is used.")
warning(xmsg,call.=FALSE)
wCateg <- 5
categMode <- 1
break
} else {
wCateg <- wCateg2
}
} else {
wCateg <- wCateg2
categMode <- 1
}
}
}
} else {
xmsg <- paste0("***253 The categ parameter provided does not contain any value. The default of categ=5 is used.")
warning(xmsg,call.=FALSE)
wCateg <- 5
categMode <- 1
break
}
} else {
if (is.numeric(wCateg)) {
categMode <- 1
break
} else {
xmsg <- paste0("***256 The categ call parameter is not 'DATA', 'COLORS', or a valid single value numeric value.",
" The default of categ=5 will be used.")
warning(xmsg,call.=FALSE)
ErrFnd <- TRUE
wCateg <- 5
categMode <- 1
break
}
}
} else {
wCategL <- paste0("c(",paste0(wCateg,collapse=", "),")")
if (is.character(wCateg)) {
suppressWarnings(wCateg2 <- as.numeric(wCateg))
if (any(is.na(wCateg2))) {
xmsg <- paste0("***262 The categ call parameter contains non-numeric value in",
" the break point vector: ",wCategL,
". The default of categ=5 is used.")
warning(xmsg,call.=FALSE)
wCateg <- 5
categMode <- 1
break
} else {
if (any(wCateg2 != sort(wCateg2))) {
xmsg <- paste0("***264 The categ call parameter breakpoint vector is not ",
"in order (low to high). Breakpoint vector has been sorted.")
warning(xmsg,call.=FALSE)
}
wCateg <- sort(wCateg2)
categMode <- 2
break
}
} else {
if (!is.numeric(wCateg)) {
xmsg <- paste0("***268 The categ call parameter contains non-numeric value(s) in",
" the break point vector: ",wCategL,
". The default of categ=5 is used.")
warning(xmsg,call.=FALSE)
wCateg <- 5
categMode <- 1
break
} else {
if (any(wCateg != sort(wCateg))) {
xmsg <- paste0("***264 The categ call parameter breakpoint vector is not ",
"in order (low to high). Breakpoint vector has been sorted.")
warning(xmsg,call.=FALSE)
}
wCateg <- sort(wCateg)
categMode <- 2
break
}
}
}
}
}
if (categMode == 1) CatNumb <- wCateg
if (categMode == 2) CatNumb <- length(wCateg)
callVarList$categMode <- categMode
callVarList$categ <- categ
callVarList$wCateg <- wCateg
callVarList$CatNumb <- CatNumb
rPM$categMode <- categMode
rPM$wCateg <- wCateg
rPM$CatNumb <- CatNumb
rPM$categ <- categ
palColors_def <- "RdYlBu"
brkPtDigits_def <- 2
if (categMode != 4) {
if ( ( is.null(palColors) || any(is.na(palColors)) || length(palColors)==0) ) {
palColors <- palColors_def
}
wPmatch <- match(toupper(palColors),rPM$RCBrewerDF$Name)
if (is.na(wPmatch)) {
xmsg <- paste0("***015 The palColors parameter value of ",palColors,
" is not valid in the RColorBrewer package. ",
"The default of 'RdYlBu' will be used."
)
warning(xmsg,call.=FALSE)
palColors <- palColors_def
} else {
palColors <- rPM$RCBrewerDF[wPmatch,"PName"]
}
if (categMode == 1) {
if (is.null(brkPtDigits) || any(is.na(brkPtDigits)) || length(brkPtDigits) == 0) {
brkPtDigits <- brkPtDigits_def
} else {
brkPtDigits <- as.integer(brkPtDigits)
if (any(is.na(brkPtDigits)) || brkPtDigits < 1 || brkPtDigits > 5) {
xmsg <- paste0("***103 The brkPtDigits call parameter must be greater than 0,",
" no greater than 5 and not NA. Set to a value of 2.")
warning(xmsg,call.=FALSE)
brkPtDigits <- brkPtDigits_def
}
}
} else {
brkPtDigits <- brkPtDigits_def
}
} else {
palColors <- palColors_def
brkPtDigits <- brkPtDigits_def
}
wPmatch <- match(toupper(palColors),rPM$RCBrewerDF$Name)
palColorsMaxNum <- rPM$RCBrewerDF[wPmatch,"maxcolors"]
callVarList$brkPtDigits <- brkPtDigits
callVarList$palColors <- palColors
callVarList$palColorsMaxNum <- palColorsMaxNum
rPM$palColors <- palColors
rPM$palColorsMaxNum <- palColorsMaxNum
rPM$brkPtDigits <- brkPtDigits
if (categMode == 1) {
catMaxNum <- palColorsMaxNum - 1
if (wCateg < 3) {
xmsg <- paste0("***258 The categ call parameter has a single value of ",wCateg," and must be => 3 as a minimum. The default of 5 will be used.")
warning(xmsg,call.=FALSE)
ErrFnd <- TRUE
wCateg <- 5
CatNumb <- 5
} else {
if (wCateg > catMaxNum) {
xmsg <- paste0("***259 The categ call parameter value has a single value of ",wCateg," and > to ",catMaxNum,". The categ will be set to ",catMaxNum,".")
warning(xmsg,call.=FALSE)
ErrFnd <- TRUE
wCateg <- catMaxNum
CatNumb <- wCateg
}
}
}
if (categMode == 2) {
catMaxNum <- palColorsMaxNum - 1
lCat <- length(wCateg)
if (wCateg[lCat] == Inf) wCateg <- wCateg[-lCat]
if (wCateg[1] == -Inf) wCateg <- wCateg[-1]
cat("wCateg:",wCateg,"\n")
lCat <- length(wCateg)
if (lCat < 3 ) {
xmsg <- paste0("***260 The categ call parameter break point list has a length < 3 items. The default of \var{categ} = 5 will be used.")
warning(xmsg,call.=FALSE)
ErrFnd <- TRUE
wCateg <- 5
CatNumb <- 5
categMode <- 1
} else {
if (lCat > catMaxNum) {
xmsg <- paste0("***261 The categ call parameter break point list has a length > ",catMaxNum," items. Only the first ",catMaxNum," values will be used.")
warning(xmsg,call.=FALSE)
ErrFnd <- TRUE
wCateg <- wCateg[1:catMaxNum]
CatNumb <- length(wCateg)
}
}
}
categ <- wCateg
callVarList$categ <- wCateg
callVarList$wCateg <- wCateg
rPM$categ <- wCateg
rPM$wCateg <- wCateg
rPM$CatNumb <- CatNumb
stateSelDel <- NULL
us48Only_def <- FALSE
if (is.null(us48Only) || any(is.na(us48Only)) || length(us48Only) == 0) {
us48Only <- us48Only_def
} else {
us48Only <- us48Only[[1]][1]
if (typeof(us48Only) != "logical") {
xmsg <- paste0("***020 us48Only parameter is not a logical value of TRUE or FALSE.",
" The default of TRUE will be used.")
warning(xmsg, call.=FALSE)
us48Only <- us48Only_def
}
}
us48OnlyFlag <- us48Only
callVarList$us48Only <- us48Only
if (us48OnlyFlag) { stateSelDel <- c(stateSelDel, "02", "15") }
includePR_def <- FALSE
includePRFlag <- FALSE
if (is.null(includePR) || any(is.na(includePR)) || length(includePR) == 0) {
includePR <- includePR_def
} else{
if (is.logical(includePR)) {
includePR <- includePR[[1]][1]
} else {
xmsg <- paste0("***022 includePR parameter is not a logical value of TRUE or FALSE.",
" The default of FALSE will be used.")
warning(xmsg, call.=FALSE)
includePR <- includePR_def
}
}
includePRFlag <- includePR
callVarList$includePR <- includePR
if (!includePRFlag) { stateSelDel <- c(stateSelDel, "72") }
rPM$stateSelDel <- stateSelDel
regionB_def <- "NONE"
regionB_caller <- FALSE
if (is.null(regionB) || any(is.na(regionB)) || length(regionB) == 0) {
regionB <- regionB_def
} else {
regionB <- stringr::str_trim(toupper(regionB[[1]]))
if (regionB == "") regionB = "NONE"
SMatch <- match(regionB,c("NONE","DATA", NA, NA, NA, NA, NA, NA, "ALL"))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***080 The regionB call parameter is ",regionB,
" and must be NONE, DATA or ALL. The default of ",regionB_def," will be used.")
warning(xmsg, call.=FALSE)
regionB <- regionB_def
} else {
regionB_caller <- TRUE
}
}
callVarList$regionB <- regionB
callVarList$regionB_caller <- regionB_caller
rPM$regionB <- regionB
rPM$regionB_caller <- regionB_caller
stateB_def <- "NONE"
stateB_caller <- FALSE
if (is.null(stateB) || any(is.na(stateB)) || length(stateB) == 0) {
stateB <- stateB_def
} else {
stateB <- stringr::str_trim(toupper(stateB[[1]]))
if (stateB == "") stateB = "NONE"
SMatch <- match(stateB,c("NONE","DATA", NA, NA, NA, "REGION", NA, NA, "ALL"))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***082 The stateB call parameter is ",stateB,
" and must be NONE, DATA, REGION, or ALL. The default of ",stateB_def," will be used.")
warning(xmsg, call.=FALSE)
stateB <- stateB_def
} else {
stateB_caller <- TRUE
}
}
callVarList$stateB <- stateB
callVarList$stateB_caller <- stateB_caller
rPM$stateB <- stateB
rPM$stateB_caller <- stateB_caller
seerB_def <- "NONE"
seerB_caller <- FALSE
if (is.null(seerB) || any(is.na(seerB)) || length(seerB) == 0) {
seerB <- seerB_def
} else {
seerB <- stringr::str_trim(toupper(seerB[[1]][1]))
if (seerB == "") seerB = seerB_def
SMatch <- match(seerB,c("NONE", "DATA", NA, NA, "STATE", "REGION", NA, NA, "ALL"))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***084 The seerB call parameter is ",seerB,
" and must be NONE, DATA, STATE, REGION, or ALL. The default of ",seerB_def," will be used.")
warning(xmsg, call.=FALSE)
seerB <- seerB_def
} else {
seerB_caller <- TRUE
}
}
callVarList$seerB <- seerB
callVarList$seerB_caller <- seerB_caller
rPM$seerB <- seerB
rPM$seerB_caller <- seerB_caller
hsaB_def <- "NONE"
hsaB_caller <- FALSE
if (is.null(hsaB) || any(is.na(hsaB)) || length(hsaB) == 0) {
hsaB <- hsaB_def
} else {
hsaB <- stringr::str_trim(toupper(hsaB[[1]][1]))
hsaB_caller <- TRUE
SMatch <- match(hsaB,c("NONE", "DATA", NA, "SEER", "STATE", NA, NA, NA, NA))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***085 The hsaB call parameter is ",hsaB,
" and must be NONE, DATA, SEER, or STATE. The default of ",hsaB_def," will be used.")
warning(xmsg, call.=FALSE)
hsaB <- hsaB_def
} else {
hsaB_caller <- TRUE
}
}
callVarList$hsaB <- hsaB
callVarList$hsaB_caller <- hsaB_caller
rPM$hsaB <- hsaB
rPM$hsaB_caller <- hsaB_caller
countyB_def <- "NONE"
countyB_caller <- FALSE
if (is.null(countyB) || any(is.na(countyB)) || length(countyB) == 0) {
countyB <- countyB_def
} else {
countyB <- stringr::str_trim(toupper(countyB[[1]][1]))
countyB_caller <- TRUE
SMatch <- match(countyB,c("NONE", "DATA", NA, "SEER", "STATE", NA, "HSA", NA, NA))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***087 The countyB call parameter is ",countyB,
" and must be NONE, DATA, HSA, SEER, or STATE. The default of DATA will be used.")
warning(xmsg, call.=FALSE)
countyB <- countyB_def
} else {
countyB_caller <- TRUE
}
}
callVarList$countyB <- countyB
callVarList$countyB_caller <- countyB_caller
rPM$countyB <- countyB
rPM$countyB_caller <- countyB_caller
tractB_def <- "NONE"
tractB_caller <- FALSE
if (is.null(tractB) || any(is.na(tractB)) || length(tractB) == 0 ) {
tractB <- tractB_def
} else {
tractB <- stringr::str_trim(toupper(tractB[[1]][1]))
if (tractB == "") tractB=tractB_def
SMatch <- match(tractB,c("NONE", "DATA", "COUNTY", "SEER", "STATE", NA, "HSA", NA, NA))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***089 tractB call parameter is ",tractB,
" and must be DATA, COUNTY, HSA, SEER or STATE. The default of DATA will be used.")
warning(xmsg, call.=FALSE)
tractB <- tractB_def
} else {
tractB_caller <- TRUE
}
}
callVarList$tractB <- tractB
callVarList$tractB_caller <- tractB_caller
rPM$tractB <- tractB
rPM$tractB_caller <- tractB_caller
fillTo_def <- "NONE"
fillTo_caller <- FALSE
if ( is.null(fillTo) || any(is.na(fillTo)) || length(fillTo) == 0 ) {
fillTo <- fillTo_def
} else {
fillTo <- stringr::str_trim(toupper(fillTo))
SMatch <- match(fillTo,c("NONE", NA, "COUNTY", "SEER", "STATE", NA, NA, NA, NA))
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***092 The fillTo call parameter is ",fillTo,
" and must be 'NONE', 'COUNTY', 'SEER', or 'STATE'.",
" The default of 'NONE' will be used.")
warning(xmsg, call.=FALSE)
fillTo <- fillTo_def
} else {
fillTo_caller <- TRUE
}
}
callVarList$fillTo <- fillTo
callVarList$fillTo_caller <- fillTo_caller
rPM$fillTo <- fillTo
rPM$fillTo_caller <- fillTo_caller
clipTo_def <- "NONE"
clipTo_caller <- FALSE
clipToNum <- 1
vClipTo <- clipTo[[1]][1]
vClipTo <- stringr::str_trim(toupper(vClipTo))
if ( is.null(clipTo) || any(is.na(clipTo)) || length(clipTo) == 0 ) {
clipTo <- clipTo_def
} else {
SList <- c("NONE", "DATA", NA, "SEER", "STATE", "REGION", "HSA", "TRUE","FALSE")
SMatch <- match(vClipTo,SList)
if (is.na(SMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***094 The clipTo call parameter is ",fillTo,
" and must be 'NONE', 'DATA', 'HSA', 'SEER', 'STATE', 'REGION' or 'TRUE'/'FALSE'.",
" The default of 'NONE' will be used.")
warning(xmsg, call.=FALSE)
clipTo <- clipTo_def
} else {
clipTo <- SList[SMatch]
clipToNum <- SMatch
if (SMatch == 8) {
clipTo <- "DATA"
clipToNum <- 2
}
if (SMatch == 9) {
clipTo <- "NONE"
clipToNum <- 1
}
clipTo_caller <- TRUE
}
}
callVarList$clipTo <- clipTo
callVarList$clipToNum <- clipToNum
callVarList$clipTo_caller <- clipTo_caller
rPM$clipTo <- clipTo
rPM$clipToNum <- clipToNum
rPM$clipTo_caller <- clipTo_caller
dataBCol_def <- rPM$ColorB_Data
dataBCol_caller <- FALSE
if ( is.null(dataBCol) || any(is.na(dataBCol)) || length(dataBCol) == 0 ) {
dataBCol <- dataBCol_def
} else {
dataBCol <- stringr::str_trim(dataBCol)
iR <- is.Color(dataBCol)
if (!iR) {
ErrFnd <- TRUE
xmsg <- paste0("***100 The dataBCol call parameter is not a valid color: ",dataBCol,", ",
" The default of 'black' will be used.")
warning(xmsg, call.=FALSE)
dataBCol <- dataBCol_def
} else {
dataBCol_caller <- TRUE
}
}
callVarList$dataBCol <- dataBCol
callVarList$dataBCol_caller <- dataBCol_caller
rPM$dataBCol <- dataBCol
rPM$dataBCol_caller <- dataBCol_caller
mTitle_def <- NA
if ( ( is.null(mTitle) || any(is.na(mTitle)) || length(mTitle) == 0 ) ) {
mTitle <- mTitle_def
} else {
if (is.character(mTitle)) {
ilen <- length(mTitle)
if (ilen == 0) {
mTitle <- mTitle_def
} else {
if (ilen > 2) {
xmsg <- paste0("***105 The 'mTitle' option can only contain one or two strings.",
" Only the first two will be used.")
warning(xmsg, call.=FALSE)
mTitle <- mTitle[1:2]
}
}
} else {
xmsg <- paste0("***106 The 'mTitle' option is not a character vector. 'mTitle' parameter is ignored.")
warning(xmsg)
mTitle <- mTitle_def
}
}
callVarList$mTitle <- mTitle
rPM$mTitle <- mTitle
mTitle.cex_def <- 1
if ( ( is.null(mTitle.cex) || any(is.na(mTitle.cex)) || length(mTitle.cex) == 0 ) ) {
mTitle.cex <- mTitle.cex_def
} else {
if (is.numeric(mTitle.cex)) {
mTitle.cex <- mTitle.cex[[1]][1]
if (mTitle.cex <= 0 || mTitle.cex > 4) {
xmsg <- paste0("***108 The 'mTitle.cex' call parameter is out of range (<=0 or >4). 'mTitle.cex' is set to the default of 1.")
warning(xmsg)
mTitle.cex <- mTitle.cex_def
}
} else {
xmsg <- paste0("***109 The 'mTitle.cex' option is not a numeric value. The 'mTitle,cex' parameter is set to the default of 1.")
warning(xmsg)
mTitle.cex <- mTitle.cex_def
}
}
callVarList$mTitle.cex <- mTitle.cex
rPM$mTitle.cex <- mTitle.cex
HatchFlag <- FALSE
Hatch2Flag <- FALSE
ErrFnd <- FALSE
hatch_caller <- FALSE
H_SettingList <- c("dataCol", "ops", "value", "col" ,"lwd", "density", "den", "angle", "range","incAngle","lab",
"hDataCol","hOps","hValue","hCol","hLwd", "hDensity","hDen","hAngle","hRange","")
HOpsList <- c("eq","ne","lt","le","gt","ge")
HOpsList2 <- c("=", "<>","<", "=<",">", "=>")
HOpsCode <- c("==","!=","<", "<=",">" ,">=")
HOpsTest <- c(HOpsList,HOpsList2,HOpsCode)
HOpsRCode <- c(HOpsCode,HOpsCode, HOpsCode)
H_dataColName <- "pValue"
H_dataColNum <- 0
H_dataCol <- "pValue"
H_data <- c()
H_ops <- ">"
H_value <- 0.05
H_range <- NA
H_range_def <- c(0,1)
H_lab <- "hatch
H_col <- rPM$ColorB_hatching
H_lwd <- 0.85
H_den <- 25
H_angle <- 45
H_incAngle <- 60
if (debug) {
cat("Hatching default setting Z-7480 \n")
cat(" parameters -- dataCol:",H_dataColName,"
cat(" range:",H_range," label:",H_lab,"\n")
cat(" col :",H_col," lwd:",H_lwd," den:",H_den," angle:",H_angle,
" IncAngle:",H_incAngle,"\n")
}
if ( !(is.null(hatch) || any(is.na(hatch)) || length(hatch) == 0) ) {
if (is.list(hatch)) {
HatchColNames <- names(hatch)
HMatch <- match(HatchColNames, H_SettingList)
HList <- hatch
HMatch1 <- is.na(HMatch)
if (any(HMatch1)) {
HBadList <- HatchColNames[HMatch1]
ErrFnd <- TRUE
xmsg <- paste0("***115 The following hatch options are not valid and be ignored:",
paste0(HBadList,collapse=", "))
warning(xmsg, call.=FALSE)
HList <- hatch[!HMatch1]
rm(HBadList, xmsg)
}
rm(HMatch1)
if (length(HList)>0) {
hatch_caller <- TRUE
HatchFlag <- TRUE
HMatch <- match(H_SettingList,names(HList))
HMatch <- HMatch[!is.na(HMatch)]
HList <- HList[HMatch]
numHList <- length(HList)
namHList <- names(HList)
for (ind in c(1:numHList)) {
var <- HList[[ind]]
nam <- namHList[ind]
if (is.factor(var)) var <- as.character(var)
if (debug) {
cat("Parsing List - name:",nam," value:",var,"\n")
}
ErrFnd <- FALSE
if (nam == "dataCol" || nam == "hDataCol") {
if (!is.na(var)) {
if (class(var) == "character" || class(var) == "numeric") {
H_dataCol <- var[[1]][1]
} else {
xmsg <- paste0("***116 The hatch option dataCol is not a character vector or numeric. The default value of ",H_dataCol," will be used.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
}
}
}
if (nam == "range" || nam == "hRange") {
InvParm <- FALSE
lenVar <- length(var)
if (lenVar == 1) {
if (!is.na(var)) {
InvParm <- TRUE
lenVar <- -1
}
H_Range <- NA
}
if (lenVar == 2) {
if (class(var) == "numeric" || class(var) == "character") {
suppressWarnings(wVal <- as.numeric(var[1:2]))
if (any(is.na(wVal))) {
InvParm <- TRUE
} else {
if (wVal[1] > wVal[2]) {
if (debug) {
xmsg <- paste0("***117 The hatch option range values are out of order. First value must be",
" less than second value. Reversed.")
warning(xmsg,call.=FALSE)
}
wVal <- rev(wVal)
}
H_range <- wVal
}
} else {
InvParm <- TRUE
}
}
if (lenVar > 2) {
InvParm <- TRUE
}
if (InvParm) {
xmsg <- paste0("***118 The hatch option range is not valid. It must be NA or a",
" vector containing 2 numeric values (low and high limits) for the range.",
" Range checking is disabled.")
warning(xmsg, call.=FALSE)
H_range <- NA
rm(xmsg)
}
}
if (nam == "value") {
wVal <- var[[1]][1]
if (is.factor(wVal)) wVal <- as.character(wVal)
H_value <- wVal
}
if (nam == "ops" || nam == "hOps") {
H_ops <- as.character(var[[1]][1])
H_ops <- tolower(H_ops)
HMatch <- match(H_ops,HOpsTest)
if (is.na(HMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***119 The comparison operator provided in the hatch ops options - ", H_ops,
" - is not valid. Hatching disabled.")
warning(xmsg, call.=FALSE)
HatchFlag <- FALSE
rm(xmsg)
} else {
H_ops <- HOpsRCode[HMatch]
}
rm(HMatch)
}
if (nam == "col" || nam == "hCol") {
wCol <- var[[1]][1]
if (!is.Color(wCol)) {
ErrFnd <- TRUE
xmsg <- paste0("***125 The hatch col option is not a valid color : ",wCol,
". The default of ",H_col," will be used.")
warning(xmsg, call.=FALSE)
wCol <- H_col
rm(xmsg)
}
H_col <- wCol
rm(wCol)
}
if (nam == "lwd" || nam == "hLwd") {
vLwd <- var[[1]][1]
suppressWarnings(wLwd <- as.numeric(vLwd))
if (is.na(wLwd)) {
ErrFnd <- TRUE
xmsg <- paste0("***126 The hatch lwd option is not numeric - ",vLwd,".",
" The default will be used.")
warning(xmsg, call.=FALSE)
wLwd <- H_lwd
rm(xmsg)
} else {
if ( wLwd < 0 || wLwd > 5 ) {
ErrFnd <- TRUE
xmsg <- paste0("***127 The hatch lwd option is ",wLwd,
" and is out of the range ( > 0 to <= 5).",
" The default value of 0.85 will be used.")
warning(xmsg, call.=FALSE)
wLwd <- H_lwd
rm(xmsg)
}
}
H_lwd <- wLwd
rm(vLwd, wLwd)
}
if (nam == "density" || nam == "den" || nam == "hDensity" || nam == "hDen") {
vDen <- var[[1]][1]
suppressWarnings(wDen <- as.numeric(vDen))
if (is.na(wDen)) {
ErrFnd <- TRUE
xmsg <- paste0("***128 The hatch density setting is not numeric - ",vDen,
" The default value of 25 will be used.")
warning(xmsg, call.=FALSE)
wDen <- H_den
rm(xmsg)
} else {
if ( wDen < 5 || wDen > 64 ) {
ErrFnd <- TRUE
xmsg <- paste0("***129 The hatch density setting is ",wDen,
" and is out of the range of > 4 to <= 64 lines per inch.",
" The default value of 25 will be used.")
warning(xmsg, call.=FALSE)
wDen <- H_den
rm(xmsg)
}
}
H_den <- wDen
rm(vDen, wDen)
}
if (nam == "angle" || nam == "hAngle") {
vAng <- var[[1]][1]
suppressWarnings(wAng <- as.numeric(vAng))
if (is.na(wAng)) {
ErrFnd <- TRUE
xmsg <- paste0("***130 The hatch angle option is not numeric.",
" The default will be used.")
warning(xmsg, call.=FALSE)
wAng <- H_angle
rm(xmsg)
} else {
if ( wAng < -360 || wAng > 360 ) {
ErrFnd <- TRUE
xmsg <- paste0("***131 The hatch angle option is out of the range of => -360 to <= 360 degrees.",
" The default will be used.")
warning(xmsg, call.=FALSE)
wAng <- H_angle
rm(xmsg)
}
}
H_angle <- wAng
rm(vAng, wAng)
}
if (nam == "incAngle" ) {
vIncAng <- var[[1]][1]
suppressWarnings(wIncAng <- as.numeric(vIncAng))
if (is.na(wIncAng)) {
ErrFnd <- TRUE
xmsg <- paste0("***132 The hatch incremental angle option (incAngle) is not numeric.",
" The default will be used.")
warning(xmsg, call.=FALSE)
wIncAng <- H_incAngle
rm(xmsg)
} else {
if ( wIncAng < -120 || wIncAng > 120 ) {
ErrFnd <- TRUE
xmsg <- paste0("***133 The hatch incremental angle setting is out of the range of => -120 to <= 120 degrees.",
" The default will be used.")
warning(xmsg, call.=FALSE)
wIncAng <- H_angle
rm(xmsg)
}
}
H_incAngle <- wIncAng
rm(vIncAng, wIncAng)
}
hLab_def <- "hatch1"
if (nam == "lab" ) {
vLab <- var[[1]][1]
wLab <- as.character(vLab)
if (is.null || is.na(wLab)) {
H_lab <- hLab_def
}
H_lab <- hLab_def
}
}
}
if (!HatchFlag) {
xmsg <- paste0("***134 A hatch call parameter error was detected.",
" The hatch parameter is disabled. See previous messages for details.")
warning(xmsg,call.=FALSE)
}
} else {
if (is.logical(hatch)) {
HatchFlag <- hatch
hatch_caller <- TRUE
} else {
ErrFnd <- TRUE
xmsg <- paste0("***135 The hatch call parameter must be a logical value (T/F)",
" or a list of options. Parameter is ignored.")
warning(xmsg, call.=FALSE)
HatchFlag <- FALSE
rm(xmsg)
}
}
} else {
HatchFlag <- FALSE
}
rPM$HatchFlag <- HatchFlag
rPM$hatch_caller <- hatch_caller
callVarList$hatch <- list(hDataCol = H_dataCol,
hDataColName = H_dataColName,
hDataColNum = H_dataColNum,
hData = H_data,
hOps = H_ops,
hValue = H_value,
hRange = H_range,
hLab = H_lab,
hCol = H_col,
hLwd = H_lwd,
hDen = H_den,
hAngle = H_angle,
hIncAngle = H_incAngle
)
rPM$hatch <- callVarList$hatch
hatch <- rPM$hatch
Hatch2Flag <- FALSE
hatch2_caller<- FALSE
H_dataColName <- "pValue"
H_dataColNum <- 0
H_dataCol <- "pValue"
H_data <- c()
H_ops <- ">"
H_value <- 0.05
H_range <- NA
H_range_def <- c(0,1)
H_lab <- "hatch
H_angle <- H_angle + H_incAngle
H2_SettingList <- c("dataCol", "ops", "value", "range","lab")
if ( !(is.null(hatch2) || any(is.na(hatch2)) || (length(hatch2) == 0)) ) {
if (is.list(hatch2)) {
HatchColNames <- names(hatch2)
HMatch <- match(HatchColNames, H2_SettingList)
HList <- hatch2
HMatch1 <- is.na(HMatch)
if (any(HMatch1)) {
HBadList <- HatchColNames[HMatch1]
ErrFnd <- TRUE
xmsg <- paste0("***120 The following hatch2 options are not valid and be ignored:",
paste0(HBadList,collapse=", "))
warning(xmsg, call.=FALSE)
HList <- hatch[!HMatch1]
rm(HBadList, xmsg)
}
rm(HMatch1)
if (length(HList)>0) {
hatch2_caller <- TRUE
Hatch2Flag <- TRUE
HMatch <- match(H2_SettingList,names(HList))
HMatch <- HMatch[!is.na(HMatch)]
HList <- HList[HMatch]
numHList <- length(HList)
namHList <- names(HList)
for (ind in c(1:numHList)) {
var <- HList[[ind]]
nam <- namHList[ind]
if (is.factor(var)) var <- as.character(var)
if (debug) {
cat("Parsing hatch2 List - name:",nam," value:",var,"\n")
}
ErrFnd <- FALSE
if (nam == "dataCol") {
if (!is.na(var)) {
if (class(var) == "character" || class(var) == "numeric") {
H_dataCol <- var[[1]][1]
} else {
xmsg <- paste0("***121 The hatch2 option dataCol is not a character vector or numeric. The default value of ",H_dataCol," will be used.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
}
}
}
if (nam == "range") {
InvParm <- FALSE
lenVar <- length(var)
if (lenVar == 1) {
if (!is.na(var)) {
InvParm <- TRUE
lenVar <- -1
}
H_Range <- NA
}
if (lenVar == 2) {
if (class(var) == "numeric" || class(var) == "character") {
suppressWarnings(wVal <- as.numeric(var[1:2]))
if (any(is.na(wVal))) {
InvParm <- TRUE
} else {
if (wVal[1] > wVal[2]) {
if (debug) {
xmsg <- paste0("***122 The hatch2 range option values are out of order. First value must be",
" less than second value. Reversed.")
warning(xmsg,call.=FALSE)
}
wVal <- rev(wVal)
}
H_range <- wVal
}
} else {
InvParm <- TRUE
}
}
if (lenVar > 2) {
InvParm <- TRUE
}
if (InvParm) {
xmsg <- paste0("***123 The hatch2 range option is not valid. It must be NA or a",
" vector containing 2 numeric values (low and high limits) for the range.",
" Range checking is disabled.")
warning(xmsg, call.=FALSE)
H_range <- NA
rm(xmsg)
}
}
if (nam == "value") {
wVal <- var[[1]][1]
if (is.factor(wVal)) wVal <- as.character(wVal)
H_value <- wVal
}
if (nam == "ops" ) {
H_ops <- as.character(var[[1]][1])
H_ops <- tolower(H_ops)
HMatch <- match(H_ops,HOpsTest)
if (is.na(HMatch)) {
ErrFnd <- TRUE
xmsg <- paste0("***124 The comparison operator provided in the hatch2 ops option - ", H_ops,
" - is not valid. Hatching disabled.")
warning(xmsg, call.=FALSE)
InvParm <- TRUE
Hatch2Flag <- FALSE
rm(xmsg)
} else {
H_ops <- HOpsRCode[HMatch]
}
rm(HMatch)
}
hLab_def <- "hatch1"
if (nam == "lab" ) {
vLab <- var[[1]][1]
wLab <- as.character(vLab)
if (is.null || is.na(wLab)) {
H_lab <- hLab_def
}
H_lab <- hLab_def
}
}
}
if (!Hatch2Flag) {
xmsg <- paste0("***136 A hatch2 call parameter error was detected.",
" The hatch2 parameter is disabled. See previous messages for details.")
warning(xmsg,call.=FALSE)
}
} else {
ErrFnd <- TRUE
xmsg <- paste0("***137 The hatch2 call parameter must be a list of options.",
" Parameter is ignored.")
warning(xmsg, call.=FALSE)
Hatch2Flag <- FALSE
rm(xmsg)
}
} else {
Hatch2Flag <- FALSE
}
rPM$Hatch2Flag <- Hatch2Flag
rPM$hatch2_caller <- hatch2_caller
callVarList$hatch2 <- list(hDataCol = H_dataCol,
hDataColName = H_dataColName,
hDataColNum = H_dataColNum,
hData = H_data,
hOps = H_ops,
hValue = H_value,
hRange = H_range,
hLab = H_lab,
hCol = H_col,
hLwd = H_lwd,
hDen = H_den,
hAngle = H_angle
)
rPM$hatch2 <- callVarList$hatch2
hatch2 <- rPM$hatch2
mLegend_caller <- FALSE
mLegendFlag <- TRUE
mLegendOpt <- mLegend
lSize <- 0.85
lNoValue <- FALSE
lNumCols <- 3
lCounts <- FALSE
lPos <- "left"
lPosv <- "bottomleft"
lPch <- 22
lLabels <- ""
L_SettingList <- c("counts", "size", "numCols","pos", "noValue", "pch", "labels")
L_SettingOld <- c("legendCnt","legendCex","cex", "legendPos","legendColn", "ncol", "nCol", "numColumns")
L_TestList <- c(L_SettingList,L_SettingOld)
L_SettingMap <- c("counts", "size", "size", "pos" ,"numCols", "numCols","numCols","numCols" )
L_ResList <- c(L_SettingList,L_SettingMap)
if (debug) {
cat("Legend Def Settings Z-8259 flag:",mLegendFlag,
" size:", lSize, " numCols:", lNumCols,
" pos:", lPos, " ", lPosv,
" pch:", lPch,
" counts:", lCounts," noValue:", lNoValue, "\n")
}
if ( is.null(mLegend) ) {
mLegend <- TRUE
mLegendFlag <- TRUE
mLegendOpt <- NULL
} else {
if ( length(mLegend) == 1 && any(is.na(mLegend)) ) {
mLegend <- TRUE
mLegendOpt <- NULL
mLegendFlag <- TRUE
}
}
if (is.logical(mLegend)) {
mLegendFlag <- mLegend[[1]][1]
mLegendOpt <- NULL
mLegend_caller <- TRUE
} else {
if (is.list(mLegend)) {
mLegendOpt <- mLegend
mLegendFlag <- TRUE
} else {
ErrFnd <- TRUE
xmsg <- paste0("***152 The 'mLegend' call parameter must be a list or logical value.",
" Parameter Ignored.")
warning(xmsg, call.=FALSE)
mLegendFlag <- TRUE
mLegendOpts <- NULL
}
}
ErrFnd <- FALSE
if (mLegendFlag) {
if (!is.null(mLegendOpt)) {
wNANULLs <- (is.na(mLegendOpt) | sapply(mLegendOpt, function(x) is.null(x)))
mLegendOpt <- mLegendOpt[!wNANULLs]
if (length(mLegendOpt) >= 1) {
mLegendOptNames <- names(mLegendOpt)
if (is.null(mLegendOptNames)) {
ErrFnd <- TRUE
xmsg <- paste0("***153 The mLegend options list does not names for each list entry.",
" The format must be mLegend=list(pos='left',numCols=4). Defaults used."
)
warning(xmsg, call.=FALSE)
} else {
lMatch <- match(mLegendOptNames,L_TestList)
badMatches <- is.na(lMatch)
if (any(badMatches)) {
BadList <- mLegendOptNames[badMatches]
ErrFnd <- TRUE
xmsg <- paste0("***154 The following options in the mLegend parameter",
" are not valid and will be ignored:",
paste0(BadList,collapse=", "),".")
warning(xmsg, call.=FALSE)
rm(BadList, xmsg)
}
mLegendOptNames <- mLegendOptNames[!badMatches]
rm(badMatches)
if (length(mLegendOptNames) > 0) {
mLegend_caller <- TRUE
optValue <- mLegendOpt$counts
if (is.null(optValue)) optValue <- mLegendOpt$legendCnt
optValue <- optValue[[1]][1]
lCounts_def <- FALSE
if (!is.null(optValue)) {
if (!is.logical(optValue)) {
xmsg <- paste0("***156 The mLegend parameter 'counts' must a logical variable.",
" Set to FALSE.")
warning (xmsg, call.=FALSE)
ErrFnd <- TRUE
lCounts <- lCounts_def
rm(xmsg)
} else {
if (any(is.na(optValue))) {
lCounts <- lCounts_def
} else {
lCounts <- optValue
if (lCounts && lNoValue) {
lNoValue <- FALSE
}
}
}
}
optValue <- mLegendOpt$size
if (is.null(optValue)) optValue <- mLegendOpt$cex
if (is.null(optValue)) optValue <- mLegendOpt$legendCex
optValue <- optValue[[1]][1]
lSize <- 0.85
if (!is.null(optValue)) {
suppressWarnings(optValue <- as.numeric(optValue))
if (any(is.na(optValue))) {
ErrFnd <- TRUE
xmsg <- paste0("***158 The mLegend parameter 'size' option must",
" be a numeric value The default is used.")
warning(xmsg, call.=FALSE)
lSize <- 0.85
rm(xmsg)
} else {
if (optValue <= 0.1 || optValue >= 5) {
ErrFnd <- TRUE
xmsg <- paste0("***160 The mLegend parameter 'size' option must be in the",
" range from 0.1 to 5. Set to 0.85.")
warning(xmsg, call.=FALSE)
lSize <- 0.85
rm(xmsg)
} else {
lSize <- optValue
}
}
}
optValue <- mLegendOpt$numCols
if (is.null(optValue)) optValue <- mLegendOpt$ncol
if (is.null(optValue)) optValue <- mLegendOpt$nCol
if (is.null(optValue)) optValue <- mLegendOpt$numColumns
if (is.null(optValue)) optValue <- mLegendOpt$legendColn
optValue <- optValue[[1]][1]
lNumCols <- 3
if (!is.null(optValue)) {
suppressWarnings(optValue <- as.numeric(optValue))
if (any(is.na(optValue)) || optValue < 1 || optValue > 8) {
xmsg <- paste0("***162 The mLegend parameter option 'numColumns' must be",
" numeric and between 1 and 8. Set to 3.")
warning(xmsg)
ErrFnd <- TRUE
lNumCols <- 3
rm(xmsg)
} else {
lNumCols <- optValue
}
}
ValidPos <- c("left", "center", "right")
LegPos <- c("bottomleft", "bottom", "bottomright",
"left", "center", "right",
"topleft", "top", "topright")
optValue <- mLegendOpt$pos
if (is.null(optValue)) { optValue <- mLegendOpt$legendPos }
optValue <- optValue[[1]][1]
lPos <- "left"
mPosInx <- 1
if (!is.null(optValue)) {
optValue <- tolower(stringr::str_trim(optValue))
mPosInx <- match(optValue,ValidPos)
lPosHere <- !is.na(mPosInx)
if (!lPosHere) {
xmsg <- paste0('***164 The legendPos parameter is not "left", "center", or "right", Set to "left".')
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
lPos <- "left"
mPosInx <- 1
rm(xmsg)
} else {
lPos <- optValue
}
}
lPosv <- LegPos[mPosInx]
if (debug) {
cat("Position:",lPos," ",mPosInx," ",lPosv,"\n")
}
optValue <- mLegendOpt$pch[[1]][1]
lPch <- 22
if (!is.null(optValue)) {
if (typeof(optValue) != "numeric") {
xmsg <- paste0("***166 The pch parameter must be a numeric value. Set to 19.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
lPch <- 22
} else {
if (optValue < 19 || optValue > 25) {
xmsg <- paste0("***167 The pch parameter must be a value between 19 and 25. Set to 19.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
lPch <- 22
} else {
lPch <- optValue
}
}
}
optValue <- mLegendOpt$noValue[[1]][1]
lNoValue_def <- FALSE
if (!is.null(optValue)) {
if (typeof(optValue) != "logical") {
xmsg <- paste0("***168 The noValue parameter must be a logical (TRUE or FALSE) value. Set to FALSE.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
lNoValue <- lNoValue_def
} else {
if (any(is.na(optValue))) {
ErrFnd <-TRUE
lNoValue <- lNoValue_def
} else {
lNoValue <- optValue
if (lCounts) lNoValue <- FALSE
}
}
}
optValue <- mLegendOpt$labels
lLabels <- ""
if (!is.null(optValue)) {
if (typeof(optValue) != "character") {
xmsg <- paste0("***170 The labels parameter must be a vector of character strings.",
" Set to an empty string.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
lLabels <- ""
} else {
if (any(is.na(lLabels))) {
lLabels <- ""
} else {
lLabels <- optValue
}
}
}
}
}
} else {
xmsg <- paste0("***172 The mLegends parameter is an empty list. ",
"The legend will be drawn using default values.")
warning(xmsg, call.=FALSE)
}
}
}
if (mLegendFlag) {
if (debug) {
cat("mLegend Settings Z-8610 counts:", lCounts, " size:", lSize,
" numCols:", lNumCols,
" pos:", lPos, " ", lPosv, " pch:", lPch, " noValue:", lNoValue,"\n")
}
}
rPM$mLegendFlag <- mLegendFlag
rPM$mLegend_caller <- mLegend_caller
callVarList$mLegend <- list(lCounts = lCounts,
lSize = lSize,
lNumCols= lNumCols,
lPos = lPos,
lPosv = lPosv,
lNoValue= lNoValue,
lPch = lPch,
lLabels = lLabels
)
rPM$mLegend <- callVarList$mLegend
mLegend <- rPM$mLegend
ErrFnd <- FALSE
dfGood <- TRUE
if (is.null(ndf)) {
dfGood <- FALSE
xmsg <- paste0("***030 The first parameter should be the statistics data.frame, but is missing or NULL.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
} else {
if (typeof(ndf) != "list" || class(ndf) != "data.frame") {
dfGood <- FALSE
xmsg <- paste0("***031 ",ndfName," parameter is not a correctly formed data.frame.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
} else {
if (!ncol(ndf) > 2) {
if (idCol == "row.names") {
if (ncol(ndf) < 1) {
xmsg <- paste0("***032 ",ndfName," data.frame muat have at least one column for Data.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
}
} else {
if (ncol(ndf) < 2) {
xmsg <- paste0("***033 ",ndfName," data.frame muat have at least two columns for ID and Data.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
}
if (nrow(ndf) < 1) {
dfGood = FALSE
xmsg <- paste0("***034 ",ndfName," data.frame does not have any data rows. Must have at least one row of data.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
}
}
}
}
}
if (ErrFnd) {
stop("***990 ERRORS found in statistic data.frame checking - Run Terminated")
}
ndfColNames <- colnames(ndf)
if (debug) {
cat("ndfColNames Z-8707 ",paste0(ndfColNames,collapse=", "),"\n")
cat("ndf dim:",dim(ndf),"\n")
str(ndf)
}
rPM$ndfColNames <- ndfColNames
callVarList$ndf <- ndf
rPM$ndf <- ndf
rPM$ndfColMax <- dim(ndf)[2]
ErrFnd <- FALSE
StopFnd <- FALSE
idCol_def <- "FIPS"
if ( is.null(idCol) ) {
idCol <- idCol_def
}
save_idCol <- idCol
idCol <- idCol[[1]][1]
if ( any(is.na(idCol)) ) {
idCol <- idCol_def
}
if (idCol == "row.names") {
ndf$XXXrnid <- row.names(ndf)
idCol <- "XXXrnid"
ndfColNames <- names(ndf)
}
rPM$ndfColNames <- ndfColNames
xxr <- CheckColnn("idCol",c("040","041","042","043"),idCol,ndf,ndfName)
if (xxr$Err) {
xmsg <- paste0("***991 The location ID column could not be found. Run Terminated.")
stop(xmsg, call.=FALSE)
}
idCol <- xxr$colName
idColNum <- xxr$colNum
idColName <- idCol
callVarList$idCol <- idCol
callVarList$idColName <- idCol
callVarList$idColNum <- idColNum
rPM$idCol <- idCol
rPM$idColName <- idCol
rPM$idColNum <- idColNum
idList <- ndf[,idCol]
if (is.factor(idList)) idList <- as.character(idList)
dataCol_def <- "Rate"
if (is.null(dataCol)) {
dataCol <- dataCol_def
}
varValue <- as.character(dataCol[[1]][1])
xxr <- CheckColnn("dataCol",c("050","051","052","053"), varValue, ndf, ndfName)
if (xxr$Err) {
xmsg <- paste0("***992 The data column could not be found. Run Terminated.")
stop(xmsg,call.=FALSE)
}
dataCol <- xxr$colName
dataColNum <- xxr$colNum
dataColName <- dataCol
callVarList$dataCol <- dataCol
callVarList$dataColName <- dataCol
callVarList$dataColNum <- dataColNum
rPM$dataCol <- dataCol
rPM$dataColName <- dataCol
rPM$dataColNum <- dataColNum
dataList <- ndf[,dataCol]
if (is.factor(dataList)) dataList <- as.character(dataList)
H_data <- rep(NA,length(dataList))
hatch <- rPM$hatch
if (HatchFlag) {
H_dataCol <- hatch$hDataCol
save_H_dataCol <- H_dataCol
xxr <- CheckColnn("hatch:dataCol",c("110","111","112","113"),H_dataCol,ndf,ndfName)
if (xxr$Err) {
xmsg <- paste0("***114 The data column for the hatch comparison could not be found. ",
" The hatch parameter has been disabled.")
warning(xmsg, call.=FALSE)
HatchFlag <- FALSE
} else {
H_dataCol <- xxr$colName
H_dataColNum <- xxr$colNum
H_dataColName <- H_dataCol
H_data <- ndf[,H_dataCol]
if (is.factor(H_data)) H_data <- as.character(H_data)
}
hatch$hDataCol <- H_dataCol
hatch$hDataColName <- H_dataColName
hatch$hDataColNum <- H_dataColNum
}
hDataList <- H_data
callVarList$HatchFlag <- HatchFlag
callVarList$hatch <- hatch
rPM$HatchFlag <- HatchFlag
rPM$hatch <- hatch
H_data <- rep(NA,length(dataList))
hatch2 <- rPM$hatch2
if (Hatch2Flag) {
H_dataCol <- hatch2$hDataCol
save_H2_dataCol <- H_dataCol
xxr <- CheckColnn("hatch2:dataCol",c("141","142","143","144"),H_dataCol,ndf,ndfName)
if (xxr$Err) {
xmsg <- paste0("***145 The data column for the hatch2 comparison could not be found. ",
" The hatch2 parameter has been disabled.")
warning(xmsg, call.=FALSE)
Hatch2Flag <- FALSE
} else {
H_dataCol <- xxr$colName
H_dataColNum <- xxr$colNum
H_dataColName <- H_dataCol
H_data <- ndf[,H_dataCol]
if (is.factor(H_data)) H_data <- as.character(H_data)
}
hatch2$hDataCol <- H_dataCol
hatch2$hDataColName<- H_dataColName
hatch2$hDataColNum <- H_dataColNum
}
h2DataList <- H_data
callVarList$Hatch2Flag <- Hatch2Flag
rPM$Hatch2Flag <- Hatch2Flag
callVarList$hatch2 <- hatch2
rPM$hatch2 <- hatch2
dataMapDF <- NULL
dataMapDF <- data.frame(ID=idList,data=dataList, hData=hDataList, h2Data=h2DataList,
stringsAsFactors=FALSE)
lenDataMapDF <- dim(dataMapDF)[1]
dataMapDF$rSeq <- seq(1,lenDataMapDF)
cNA <- rep(as.character(NA),lenDataMapDF)
dataMapDF$good <- TRUE
dataMapDF$rgID <- cNA
dataMapDF$stID <- cNA
dataMapDF$saID <- cNA
dataMapDF$HSAID <- cNA
dataMapDF$stcoID <- cNA
dataMapDF$stcotrID <- cNA
dataMapDF$cat <- 0
dataMapDF$col <- "white"
dataMapDF$hRes <- FALSE
dataMapDF$h2Res <- FALSE
rPM$dataMapDF <- dataMapDF
xRes <- SM_Build(rPM)
MV <- xRes$MV
rPM <- xRes$rPM
rPM <- SM_Categ(rPM)
if (rPM$mLegend$lLabels != "") {
if (length(rPM$mLegend$lLabels) != rPM$CatNumb) {
xmsg <- paste0("***280 The labels parameter must have one entry for each categories. ",
"Set to an empty string.")
warning(xmsg, call.=FALSE)
ErrFnd <- TRUE
rPM$mLegend$lLabels <- ""
}
}
if (rPM$HatchFlag || rPM$Hatch2Flag ) {
rPM <- SM_Hatching(rPM)
}
HatchFlag <- rPM$HatchFlag
Hatch2Flag <- rPM$Hatch2Flag
dataMapDFLen <- dim(rPM$dataMapDF)[1]
if (debug) {
xmsg <- paste0("***295 Number of locations found in the Rate Table with borders: ",dataMapDFLen)
print(xmsg)
}
if (dataMapDFLen > 0) {
dataMapDF <- rPM$dataMapDF
data_data_sel <- MV$data_data_sel
data_data_sel$col <- "white"
data_data_sel$cat <- 0
data_data_sel$hRes <- FALSE
data_data_sel$h2Res <- FALSE
data_data_sel[dataMapDF$ID,"col"] <- dataMapDF$col
data_data_sel[dataMapDF$ID,"cat"] <- dataMapDF$cat
data_data_sel[dataMapDF$ID,"hRes"] <- dataMapDF$hRes
data_data_sel[dataMapDF$ID,"h2Res"] <- dataMapDF$h2Res
if (debug) {
cat("Number of polygons in areas with data Z-9174 : ", dim(data_data_sel)[1], "\n")
}
MV$data_data_sel <- data_data_sel
if (debug) {
cat("Color and dataMapDF table Z-9185 :\n")
cat("data_data_sel:\n")
print(data_data_sel)
cat("dataMapDF:\n")
print(dataMapDF)
}
wbox <- SM_Mapper(rPM, MV)
MV$MapBox <- wbox
if (mLegendFlag) {
SM_Legend(rPM, MV)
}
if (!(is.null(mTitle) || any(is.na(mTitle)))) {
title(main=mTitle, cex = mTitle.cex)
}
if (debug) {
xRes <- list(lim=wbox, proj4=rPM$CRSproj4, rPM=rPM, MV=MV)
} else {
xRes <- list(lim=wbox, proj4=rPM$CRSproj4)
}
invisible(xRes)
} else {
wbox2 <- matrix(c(MV$xlPlot,MV$ylPlot),ncol=2,byrow=TRUE,dimnames=list(c("x","y"), c("min","max")))
if (debug) {
xRes <- list(lim=wbox2, proj4=rPM$CRSproj4, rPM=rPM, MV=MV)
} else {
xRes <- list(lim=wbox2, proj4=rPM$CRSproj4)
}
invisible(xRes)
}
}
|
box.test <- function(formula, data, alpha = 0.05, na.rm = TRUE, verbose = TRUE) {
data <- model.frame(formula, data)
dp <- as.character(formula)
DNAME <- paste(dp[[2L]], "and", dp[[3L]])
METHOD <- "Box F Test"
if (na.rm){
completeObs <- complete.cases(data)
data <- data[completeObs,]
}
if (any(colnames(data)==dp[[3L]])==FALSE) stop("The name of group variable does not match the variable names in the data. The group variable must be one factor.")
if (any(colnames(data)==dp[[2L]])==FALSE) stop("The name of response variable does not match the variable names in the data.")
y = data[[dp[[2L]]]]
group = data[[dp[[3L]]]]
if (!(is.factor(group)|is.character(group))) stop("The group variable must be a factor or a character.")
if (is.character(group)) group <- as.factor(group)
if (!is.numeric(y)) stop("The response must be a numeric variable.")
n <- length(y)
x.levels <- levels(factor(group))
k <- length(x.levels)
y.means <- y.n <- y.vars <- NULL
for (i in x.levels) {
y.means[i] <- mean(y[group==i])
y.n[i] <- length(y[group==i])
y.vars[i] <- var(y[group==i])
}
f <- y.n/length(y)
df1 <- (sum((1 - f) * y.vars))^2/((sum(y.vars * f))^2 + sum((y.vars^2) * (1 - 2 * f)))
df2 <- ((sum((1 - f) * y.vars))^2)/((sum(y.vars^2 * (1 - f)^2))/sum(y.n - 1))
Ftest <- (sum(y.n * ((y.means - mean(y))^2)))/(sum((1 - (y.n/length(y))) * y.vars))
p.value=pf(Ftest,df1,df2,lower.tail = F)
if (verbose) {
cat("\n", "",METHOD,paste("(alpha = ",alpha,")",sep = ""), "\n",
sep = " ")
cat("-------------------------------------------------------------",
"\n", sep = " ")
cat(" data :", DNAME, "\n\n", sep = " ")
cat(" statistic :", Ftest, "\n", sep = " ")
cat(" num df :", df1, "\n", sep = " ")
cat(" denom df :", df2, "\n", sep = " ")
cat(" p.value :", p.value, "\n\n", sep = " ")
cat(if (p.value > alpha) {
" Result : Difference is not statistically significant."
}
else {
" Result : Difference is statistically significant."
}, "\n")
cat("-------------------------------------------------------------",
"\n\n", sep = " ")
}
result <- list()
result$statistic <- Ftest
result$parameter <- c(df1,df2)
result$p.value <- p.value
result$alpha <- alpha
result$method <- METHOD
result$data <- data
result$formula <- formula
attr(result, "class") <- "owt"
invisible(result)
} |
if ( !isGeneric('mapView') ) {
setGeneric('mapView', function(x, ...)
standardGeneric('mapView'))
}
setMethod('mapView', signature(x = 'RasterLayer'),
function(x,
map = NULL,
maxpixels = mapviewGetOption("mapview.maxpixels"),
col.regions = mapviewGetOption("raster.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
use.layer.names = mapviewGetOption("use.layer.names"),
map.types = mapviewGetOption("basemaps"),
alpha.regions = 0.8,
legend = mapviewGetOption("legend"),
legend.opacity = 1,
trim = mapviewGetOption("trim"),
verbose = mapviewGetOption("verbose"),
layer.name = NULL,
homebutton = mapviewGetOption("homebutton"),
native.crs = mapviewGetOption("native.crs"),
method = mapviewGetOption("method"),
label = TRUE,
query.type = mapviewGetOption("query.type"),
query.digits = mapviewGetOption("query.digits"),
query.position = mapviewGetOption("query.position"),
query.prefix = mapviewGetOption("query.prefix"),
viewer.suppress = mapviewGetOption("viewer.suppress"),
...) {
if (mapviewGetOption("platform") != "leaflet") {
warning(
sprintf(
"platform '%s' currently doesn't support raster data."
, mapviewGetOption("platform")
)
, " switching to platform 'leaflet'"
, call. = FALSE
)
mapviewOptions(platform = "leaflet")
}
if (mapviewGetOption("platform") == "leaflet") {
leafletRL(x,
map = map,
maxpixels = maxpixels,
col.regions = col.regions,
at = at,
na.color = na.color,
use.layer.names = use.layer.names,
map.types = map.types,
alpha.regions = alpha.regions,
legend = legend,
legend.opacity = legend.opacity,
trim = trim,
verbose = verbose,
layer.name = layer.name,
homebutton = homebutton,
native.crs = native.crs,
method = method,
label = label,
query.type = query.type,
query.digits = query.digits,
query.position = query.position,
query.prefix = query.prefix,
viewer.suppress = viewer.suppress,
...)
} else {
NULL
}
}
)
.stars_method = function(x,
band = 1,
map = NULL,
maxpixels = mapviewGetOption("mapview.maxpixels"),
col.regions = mapviewGetOption("raster.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
use.layer.names = mapviewGetOption("use.layer.names"),
map.types = mapviewGetOption("basemaps"),
alpha.regions = 0.8,
legend = mapviewGetOption("legend"),
legend.opacity = 1,
trim = mapviewGetOption("trim"),
verbose = mapviewGetOption("verbose"),
layer.name = NULL,
homebutton = mapviewGetOption("homebutton"),
native.crs = mapviewGetOption("native.crs"),
method = mapviewGetOption("method"),
label = TRUE,
query.type = mapviewGetOption("query.type"),
query.digits = mapviewGetOption("query.digits"),
query.position = mapviewGetOption("query.position"),
query.prefix = mapviewGetOption("query.prefix"),
viewer.suppress = mapviewGetOption("viewer.suppress"),
pane = "auto",
...) {
dims <- dim(x)
n_pixels <- dims[1] * dims[2]
do.downscale <- if (n_pixels > maxpixels) {
TRUE
} else {
FALSE
}
if (inherits(x, "stars_proxy")) {
if (!do.downscale) {
x <- stars::st_as_stars(x)
} else {
asp <- dims[1] / dims[2]
y_new <- sqrt(maxpixels / asp)
x_new <- y_new * asp
downsample <- dims[1] / x_new
x <- stars::st_as_stars(x, downsample = downsample - 1)
message("Number of pixels is above ", maxpixels, ".",
"Only about ", maxpixels, " pixels will be shown.\n",
"You can increase the value of `maxpixels` to ", prod(dims), " to avoid this.")
}
} else {
if (do.downscale) {
message("Number of pixels is above ", maxpixels, ". ",
"Automatic downsampling of `stars` object is not yet implemented, so rendering may be slow.\n",
"You can pass a `stars` proxy object to mapview to get automatic downsampling.")
}
}
if (mapviewGetOption("platform") != "leaflet") {
warning(
sprintf(
"platform '%s' currently doesn't support stars data."
, mapviewGetOption("platform")
)
, " switching to platform 'leaflet'"
, call. = FALSE
)
mapviewOptions(platform = "leaflet")
}
if (mapviewGetOption("platform") == "leaflet") {
leaflet_stars(x,
band = band,
map = map,
maxpixels = maxpixels,
col.regions = col.regions,
at = at,
na.color = na.color,
use.layer.names = use.layer.names,
map.types = map.types,
alpha.regions = alpha.regions,
legend = legend,
legend.opacity = legend.opacity,
trim = trim,
verbose = verbose,
layer.name = layer.name,
homebutton = homebutton,
native.crs = native.crs,
method = method,
label = label,
query.type = query.type,
query.digits = query.digits,
query.position = query.position,
query.prefix = query.prefix,
viewer.suppress = viewer.suppress,
pane = pane,
...)
} else {
NULL
}
}
setMethod('mapView', signature(x = 'stars'), .stars_method)
setMethod('mapView', signature(x = 'stars_proxy'), .stars_method)
setMethod('mapView', signature(x = 'RasterStackBrick'),
function(x,
map = NULL,
maxpixels = mapviewGetOption("mapview.maxpixels"),
col.regions = mapviewGetOption("raster.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
use.layer.names = TRUE,
map.types = mapviewGetOption("basemaps"),
legend = mapviewGetOption("legend"),
legend.opacity = 1,
trim = TRUE,
verbose = mapviewGetOption("verbose"),
homebutton = mapviewGetOption("homebutton"),
method = mapviewGetOption("method"),
label = TRUE,
query.type = c("mousemove", "click"),
query.digits = mapviewGetOption("query.digits"),
query.position = mapviewGetOption("query.position"),
query.prefix = "Layer",
viewer.suppress = mapviewGetOption("viewer.suppress"),
...) {
if (mapviewGetOption("platform") != "leaflet") {
warning(
sprintf(
"platform '%s' currently doesn't support raster data."
, mapviewGetOption("platform")
)
, " switching to platform 'leaflet'"
, call. = FALSE
)
mapviewOptions(platform = "leaflet")
}
if (mapviewGetOption("platform") == "leaflet") {
leafletRSB(x,
map = map,
maxpixels = maxpixels,
col.regions = col.regions,
at = at,
na.color = na.color,
use.layer.names = use.layer.names,
map.types = map.types,
legend = legend,
legend.opacity = legend.opacity,
trim = trim,
verbose = verbose,
homebutton = homebutton,
method = method,
label = label,
query.type = query.type,
query.digits = query.digits,
query.position = query.position,
query.prefix = query.prefix,
viewer.suppress = viewer.suppress,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'Satellite'),
function(x,
map = NULL,
maxpixels = mapviewGetOption("mapview.maxpixels"),
col.regions = mapviewGetOption("raster.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
map.types = mapviewGetOption("basemaps"),
legend = mapviewGetOption("legend"),
legend.opacity = 1,
trim = TRUE,
verbose = mapviewGetOption("verbose"),
homebutton = mapviewGetOption("homebutton"),
method = c("bilinear", "ngb"),
label = TRUE,
...) {
if (mapviewGetOption("platform") != "leaflet") {
warning(
sprintf(
"platform '%s' currently doesn't support Satellite data."
, mapviewGetOption("platform")
)
, " switching to platform 'leaflet'"
, call. = FALSE
)
mapviewOptions(platform = "leaflet")
}
if (mapviewGetOption("platform") == "leaflet") {
leafletSatellite(x,
map = map,
maxpixels = maxpixels,
col.regions = col.regions,
at = at,
na.color = na.color,
map.types = map.types,
legend = legend,
legend.opacity = legend.opacity,
trim = trim,
verbose = verbose,
homebutton = homebutton,
method = method,
label = label,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'sf'),
function(x,
map = NULL,
pane = "auto",
canvas = useCanvas(x),
viewer.suppress = mapviewGetOption("viewer.suppress"),
zcol = NULL,
burst = FALSE,
color = mapviewGetOption("vector.palette"),
col.regions = mapviewGetOption("vector.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
cex = 6,
lwd = lineWidth(x),
alpha = 0.9,
alpha.regions = regionOpacity(x),
na.alpha = regionOpacity(x),
map.types = mapviewGetOption("basemaps"),
verbose = mapviewGetOption("verbose"),
popup = TRUE,
layer.name = NULL,
label = zcol,
legend = mapviewGetOption("legend"),
legend.opacity = 1,
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
highlight = mapviewHighlightOptions(x, alpha.regions, alpha, lwd),
maxpoints = getMaxFeatures(x),
...) {
if (nrow(x) == 0) {
stop("\n", deparse(substitute(x, env = parent.frame())),
" does not contain data \n", call. = FALSE)
}
dims = try(sf::st_dimension(x), silent = TRUE)
if (inherits(dims, "try-error")) {
x = sf::st_cast(x)
}
if (!inherits(dims, "try-error")) {
if (length(unique(dims)) > 1 |
inherits(sf::st_geometry(x), "sfc_GEOMETRY")) {
x = sf::st_cast(x)
}
}
if (is.null(zcol) & is.null(legend)) legend = FALSE
if (!is.null(zcol) && !all(zcol %in% colnames(x))) {
stop("\n", "at least one of the following columns: \n",
"'", paste(zcol, collapse = "', '"), "' \nnot found in ",
deparse(substitute(x, env = parent.frame())),
call. = FALSE)
}
if (is.character(burst)) {
zcol = burst
burst = TRUE
}
if (length(zcol) > 1) {
x = x[, zcol]
burst = TRUE
}
if (burst) {
by_row = FALSE
if (!is.null(zcol) && burst && length(zcol) == 1) {
color = vectorColors(x = x,
zcol = zcol,
colors = color,
at = at,
na.color = na.color)
if (length(color) > 1)
color = color[order(x[[zcol]])]
col.regions = vectorColRegions(x = x,
zcol = zcol,
col.regions = col.regions,
at = at,
na.color = na.color)
if (length(col.regions) > 1)
col.regions = col.regions[order(x[[zcol]])]
popup = leafpop::popupTable(x, className = "mapview-popup")[order(x[[zcol]])]
label = makeLabels(x, zcol)[order(x[[zcol]])]
by_row = TRUE
}
popup = popup
lwd = lwd
alpha.regions = alpha.regions
x <- burst(x = x,
zcol = zcol,
burst = burst)
if (length(layer.name) == length(x)) {
names(x) = layer.name
}
}
if (inherits(x, "list")) {
mapView(x,
map = map,
zcol = zcol,
burst = FALSE,
color = color,
col.regions = col.regions,
popup = popup,
label = label,
homebutton = homebutton,
legend = legend,
map.types = map.types,
layer.name = layer.name,
alpha = alpha,
alpha.regions = alpha.regions,
na.alpha = na.alpha,
canvas = canvas,
viewer.suppress = viewer.suppress,
pane = pane,
cex = cex,
lwd = lwd,
by_row = by_row,
...)
} else if (mapviewGetOption("platform") == "leaflet") {
leaflet_sf(x,
map = map,
pane = pane,
zcol = zcol,
color = color,
col.regions = col.regions,
at = at,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
na.alpha = na.alpha,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
canvas = canvas,
viewer.suppress = viewer.suppress,
...)
} else if (mapviewGetOption("platform") == "leafgl") {
leafgl_sf(x,
map = map,
zcol = zcol,
color = color,
col.regions = col.regions,
at = at,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
na.alpha = na.alpha,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
viewer.suppress = viewer.suppress,
...)
} else if (mapviewGetOption("platform") == "mapdeck") {
mapdeck_sf(x,
map = map,
zcol = zcol,
color = color,
col.regions = col.regions,
at = at,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
na.alpha = na.alpha,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
viewer.suppress = viewer.suppress,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'sfc'),
function(x,
map = NULL,
pane = "auto",
canvas = useCanvas(x),
viewer.suppress = mapviewGetOption("viewer.suppress"),
color = standardColor(x),
col.regions = standardColRegions(x),
at = NULL,
na.color = mapviewGetOption("na.color"),
cex = 6,
lwd = lineWidth(x),
alpha = 0.9,
alpha.regions = regionOpacity(x),
map.types = mapviewGetOption("basemaps"),
verbose = mapviewGetOption("verbose"),
popup = NULL,
layer.name = deparse(substitute(x,
env = parent.frame())),
label = makeLabels(x),
legend = mapviewGetOption("legend"),
legend.opacity = 1,
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
highlight = mapviewHighlightOptions(x, alpha.regions, alpha, lwd),
maxpoints = getMaxFeatures(x),
...) {
if (length(x) == 0) {
stop("\n", deparse(substitute(x, env = parent.frame())),
" does not contain data \n", call. = FALSE)
}
if (length(unique(sf::st_dimension(x))) > 1) {
x = sf::st_cast(x)
}
if (mapviewGetOption("platform") == "leaflet") {
leaflet_sfc(x,
map = map,
pane = pane,
canvas = canvas,
viewer.suppress = viewer.suppress,
color = color,
col.regions = col.regions,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
...)
} else if (mapviewGetOption("platform") == "leafgl") {
leafgl_sfc(x,
map = map,
pane = pane,
canvas = canvas,
viewer.suppress = viewer.suppress,
color = color,
col.regions = col.regions,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
...)
} else if (mapviewGetOption("platform") == "mapdeck") {
mapdeck_sfc(x,
map = map,
pane = pane,
canvas = canvas,
viewer.suppress = viewer.suppress,
color = color,
col.regions = col.regions,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'character'),
function(x,
map = NULL,
tms = TRUE,
color = standardColor(),
col.regions = standardColRegions(),
at = NULL,
na.color = mapviewGetOption("na.color"),
cex = 6,
lwd = 2,
alpha = 0.9,
alpha.regions = 0.6,
na.alpha = 0.6,
map.types = mapviewGetOption("basemaps"),
verbose = FALSE,
layer.name = x,
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
canvas = FALSE,
viewer.suppress = mapviewGetOption("viewer.suppress"),
...) {
pf = mapviewGetOption("platform")
if (pf != "leaflet") {
warning(
"platform "
, "'", pf, "'"
, " currently does not support tile rendering"
, " switching to platform 'leaflet'."
, call. = FALSE
)
mapviewOptions(platform = "leaflet")
}
if (mapviewGetOption("platform") == "leaflet") {
if (utils::file_test("-d", x)) {
leaflet_tiles(x = x,
map = map,
tms = tms,
map.types = map.types,
verbose = verbose,
layer.name = layer.name,
homebutton = homebutton,
native.crs = native.crs,
viewer.suppress = viewer.suppress,
...)
} else if (utils::file_test("-f", x)) {
layer.name = basename(tools::file_path_sans_ext(layer.name))
leaflet_file(x = x,
map = map,
color = color,
col.regions = col.regions,
at = at,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
na.alpha = na.alpha,
map.types = map.types,
verbose = verbose,
layer.name = layer.name,
homebutton = homebutton,
native.crs = native.crs,
canvas = canvas,
viewer.suppress = viewer.suppress,
...)
} else {
stop(sprintf("%s is not a directory!", layer.name),
call. = FALSE)
}
}
}
)
setMethod('mapView', signature(x = 'numeric'),
function(x, y, type = "p", grid = TRUE, label, ...) {
if (missing(label)) {
if (!missing(y)) {
labs = lapply(seq(length(x)), function(i) {
paste0("x : ", x[i], '<br>',
"y : ", y[i])
})
label = lapply(labs, htmltools::HTML)
} else {
labs = lapply(seq(length(x)), function(i) {
paste0("x : ", seq_along(x)[i], '<br>',
"y : ", x[i])
})
label = lapply(labs, htmltools::HTML)
}
}
if (type == "l") label = NULL
xyView(x = x,
y = y,
type = type,
grid = grid,
label = label,
...)
}
)
setMethod('mapView', signature(x = 'data.frame'),
function(x,
xcol,
ycol,
grid = TRUE,
aspect = 1,
popup = leafpop::popupTable(x, className = "mapview-popup"),
label,
crs = NA,
...) {
if (missing(xcol) | missing(ycol)) {
obj = deparse(substitute(x, env = parent.frame()))
msg = paste0("\noops! Arguments xcol and/or ycol are missing!\n",
"You probably expected ", obj,
" to be a spatial object. \nHowever it is of class ",
class(x), ". \nEither convert ", obj, " to a spatial object ",
"or provide xcol and ycol.")
stop(msg, call. = FALSE)
}
if (missing(label)) {
labs = lapply(seq(nrow(x)), function(i) {
paste0(xcol, " (x) : ", x[[xcol]][i], '<br>',
ycol, " (y) : ", x[[ycol]][i])
})
label = lapply(labs, htmltools::HTML)
}
xyView(x = xcol,
y = ycol,
data = x,
grid = grid,
aspect = aspect,
popup = popup,
label = label,
crs = crs,
...)
}
)
setMethod('mapView', signature(x = 'XY'),
function(x,
map = NULL,
pane = "auto",
canvas = useCanvas(x),
viewer.suppress = mapviewGetOption("viewer.suppress"),
color = standardColor(x),
col.regions = standardColRegions(x),
at = NULL,
na.color = mapviewGetOption("na.color"),
cex = 6,
lwd = lineWidth(x),
alpha = 0.9,
alpha.regions = regionOpacity(x),
map.types = mapviewGetOption("basemaps"),
verbose = mapviewGetOption("verbose"),
popup = NULL,
layer.name = deparse(substitute(x,
env = parent.frame(1))),
label = makeLabels(x),
legend = mapviewGetOption("legend"),
legend.opacity = 1,
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
highlight = mapviewHighlightOptions(x, alpha.regions, alpha, lwd),
maxpoints = getMaxFeatures(x),
...) {
if (mapviewGetOption("platform") == "leaflet") {
x = sf::st_cast(sf::st_sfc(x))
leaflet_sfc(x,
map = map,
pane = pane,
canvas = canvas,
viewer.suppress = viewer.suppress,
color = color,
col.regions = col.regions,
na.color = na.color,
cex = cex,
lwd = lwd,
alpha = alpha,
alpha.regions = alpha.regions,
map.types = map.types,
verbose = verbose,
popup = popup,
layer.name = layer.name,
label = label,
legend = legend,
legend.opacity = legend.opacity,
homebutton = homebutton,
native.crs = native.crs,
highlight = highlight,
maxpoints = maxpoints,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'XYZ'),
function(x,
layer.name = deparse(substitute(x,
env = parent.frame(1))),
...) {
mapview(sf::st_zm(x), layer.name = layer.name, ...)
}
)
setMethod('mapView', signature(x = 'XYM'),
function(x,
layer.name = deparse(substitute(x,
env = parent.frame(1))),
...) {
mapview(sf::st_zm(x), layer.name = layer.name, ...)
}
)
setMethod('mapView', signature(x = 'XYZM'),
function(x,
layer.name = deparse(substitute(x,
env = parent.frame(1))),
...) {
mapview(sf::st_zm(x), layer.name = layer.name, ...)
}
)
setMethod('mapView', signature(x = 'bbox'),
function(x,
layer.name = deparse(substitute(x,
env = parent.frame(1))),
alpha.regions = 0.2,
...) {
mapview(sf::st_as_sfc(x),
layer.name = layer.name,
alpha.regions = alpha.regions,
...)
}
)
setMethod('mapView', signature(x = 'missing'),
function(map.types = mapviewGetOption("basemaps"), ...) {
if (mapviewGetOption("platform") == "leaflet") {
leafletMissing(map.types, ...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'NULL'),
function(x, ...) {
NULL
}
)
setMethod('mapView', signature(x = 'list'),
function(x,
map = NULL,
zcol = NULL,
burst = FALSE,
color = mapviewGetOption("vector.palette"),
col.regions = mapviewGetOption("vector.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
cex = 6,
lwd = lapply(x, lineWidth),
alpha = 0.9,
alpha.regions = lapply(x, regionOpacity),
na.alpha = lapply(x, regionOpacity),
map.types = mapviewGetOption("basemaps"),
verbose = mapviewGetOption("verbose"),
popup = TRUE,
layer.name = deparse(substitute(x,
env = parent.frame())),
label = lapply(x, makeLabels),
legend = mapviewGetOption("legend"),
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
...) {
if ("by_row" %in% names(list(...))) {
listify = listifyer(x, by_row = list(...)$by_row)
} else {
listify = listifyer(x)
}
if (is.null(popup)) popup = FALSE
lyrnms = makeListLayerNames(x, layer.name)
m <- Reduce("+", lapply(seq(x), function(i) {
mapView(x = x[[i]],
map = map,
zcol = listify(zcol)[[i]],
color = listify(color)[[i]],
col.regions = listify(col.regions)[[i]],
at = listify(at)[[i]],
na.color = listify(na.color)[[i]],
cex = listify(cex)[[i]],
lwd = listify(lwd)[[i]],
alpha = listify(alpha)[[i]],
alpha.regions = listify(alpha.regions)[[i]],
map.types = map.types,
verbose = verbose,
popup = ifelse(isTRUE(popup), TRUE, listify(popup)[[i]]),
layer.name = lyrnms[[i]],
label = ifelse(length(label[[i]]) == 0, FALSE, listify(label)[[i]]),
legend = listify(legend)[[i]],
homebutton = listify(homebutton)[[i]],
native.crs = native.crs,
...)
}))@map
if (length(getLayerNamesFromMap(m)) > 1) {
m = leaflet::hideGroup(map = m,
group = layers2bHidden(m, ...))
}
out <- new("mapview", object = x, map = m)
return(out)
}
)
if ( !isGeneric('mapview') ) {
setGeneric('mapview', function(...)
standardGeneric('mapview'))
}
setMethod('mapview', signature('ANY'),
function(...) mapView(...))
setMethod('mapView', signature(x = 'SpatialPixelsDataFrame'),
function(x,
map = NULL,
zcol = NULL,
maxpixels = mapviewGetOption("mapview.maxpixels"),
col.regions = mapviewGetOption("raster.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
use.layer.names = FALSE,
map.types = mapviewGetOption("basemaps"),
alpha.regions = 0.8,
legend = mapviewGetOption("legend"),
legend.opacity = 1,
trim = TRUE,
verbose = mapviewGetOption("verbose"),
layer.name = NULL,
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
method = mapviewGetOption("method"),
label = TRUE,
query.type = c("mousemove", "click"),
query.digits,
query.position = "topright",
query.prefix = "Layer",
viewer.suppress = mapviewGetOption("viewer.suppress"),
...) {
if (mapviewGetOption("platform") == "leaflet") {
leafletPixelsDF(x = x,
map = map,
zcol = zcol,
maxpixels = maxpixels,
col.regions = col.regions,
at = at,
na.color = na.color,
use.layer.names = use.layer.names,
map.types = map.types,
alpha.regions = alpha.regions,
legend = legend,
legend.opacity = legend.opacity,
trim = trim,
verbose = verbose,
layer.name = layer.name,
homebutton = homebutton,
native.crs = native.crs,
method = method,
label = label,
query.type = query.type,
query.digits = query.digits,
query.position = query.position,
query.prefix = query.prefix,
viewer.suppress = viewer.suppress,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'SpatialGridDataFrame'),
function(x,
map = NULL,
zcol = NULL,
maxpixels = mapviewGetOption("mapview.maxpixels"),
col.regions = mapviewGetOption("raster.palette"),
at = NULL,
na.color = mapviewGetOption("na.color"),
use.layer.names = FALSE,
map.types = mapviewGetOption("basemaps"),
alpha.regions = 0.8,
legend = mapviewGetOption("legend"),
legend.opacity = 1,
trim = TRUE,
verbose = mapviewGetOption("verbose"),
layer.name = NULL,
homebutton = mapviewGetOption("homebutton"),
native.crs = FALSE,
method = mapviewGetOption("method"),
label = TRUE,
query.type = c("mousemove", "click"),
query.digits,
query.position = "topright",
query.prefix = "Layer",
viewer.suppress = mapviewGetOption("viewer.suppress"),
...) {
if (mapviewGetOption("platform") == "leaflet") {
leafletPixelsDF(x = as(x, "SpatialPixelsDataFrame"),
map = map,
zcol = zcol,
maxpixels = maxpixels,
col.regions = col.regions,
at = at,
na.color = na.color,
use.layer.names = use.layer.names,
map.types = map.types,
alpha.regions = alpha.regions,
legend = legend,
legend.opacity = legend.opacity,
trim = trim,
verbose = verbose,
layer.name = layer.name,
homebutton = homebutton,
native.crs = native.crs,
method = method,
label = label,
query.type = query.type,
query.digits = query.digits,
query.position = query.position,
query.prefix = query.prefix,
viewer.suppress = viewer.suppress,
...)
} else {
NULL
}
}
)
setMethod('mapView', signature(x = 'SpatialPointsDataFrame'),
function(x,
zcol = NULL,
layer.name = NULL,
...) {
if (is.null(layer.name))
layer.name = makeLayerName(x, zcol, up = 2)
mapView(st_as_sf(x), layer.name = layer.name, zcol = zcol, ...)
}
)
setMethod('mapView', signature(x = 'SpatialPoints'),
function(x,
zcol = NULL,
layer.name = NULL,
...) {
if (is.null(layer.name))
layer.name = makeLayerName(x, zcol, up = 2)
mapView(st_as_sfc(x), layer.name = layer.name, zcol = zcol, ...)
}
)
setMethod('mapView', signature(x = 'SpatialPolygonsDataFrame'),
function(x,
zcol = NULL,
layer.name = NULL,
...) {
if (is.null(layer.name))
layer.name = makeLayerName(x, zcol, up = 2)
mapView(st_as_sf(x), layer.name = layer.name, zcol = zcol, ...)
}
)
setMethod('mapView', signature(x = 'SpatialPolygons'),
function(x,
zcol = NULL,
layer.name = NULL,
...) {
if (is.null(layer.name))
layer.name = makeLayerName(x, zcol, up = 2)
mapView(st_as_sfc(x), layer.name = layer.name, zcol = zcol, ...)
}
)
setMethod('mapView', signature(x = 'SpatialLinesDataFrame'),
function(x,
zcol = NULL,
layer.name = NULL,
...) {
if (is.null(layer.name))
layer.name = makeLayerName(x, zcol, up = 2)
mapView(st_as_sf(x), layer.name = layer.name, zcol = zcol, ...)
}
)
setMethod('mapView', signature(x = 'SpatialLines'),
function(x,
zcol = NULL,
layer.name = NULL,
...) {
if (is.null(layer.name))
layer.name = makeLayerName(x, zcol, up = 2)
mapView(st_as_sfc(x), layer.name = layer.name, zcol = zcol, ...)
}
) |
test1 <- "\"Header\nLine Two\"\nValue"
cat(test1)
readr::read_csv(test1) |
model_stochastic_simulateR <- function(init_obs_current, init_obs_daily, period_start, times, pars, fix_pars, T_predict, ...){
stochastic_sampleR <- function(stage_pars, fix_pars, old_values) {
b = stage_pars[1]
r = stage_pars[2]
alpha_p = fix_pars[1]
alpha_u = fix_pars[2]
beta_1 = fix_pars[3]
beta_2 = fix_pars[4]
delta_1 = fix_pars[5]
delta_2 = fix_pars[6]
lambda = fix_pars[7]
mu = fix_pars[8]
mu_c = fix_pars[9]
De = fix_pars[10]
Dr = fix_pars[11]
f = fix_pars[12]
N = fix_pars[13]
S = old_values[1]
E = old_values[2]
U = old_values[3]
P = old_values[4]
Fa = old_values[5]
RU = old_values[6]
RR = old_values[7]
DU = old_values[8]
DR = old_values[9]
pS_vec <- c( b * (alpha_p * P + alpha_u * U + Fa) / N , mu, 1 - b * (alpha_p * P + alpha_u * U + Fa) / N - mu)
sample_S <- rmultinom(1, size = S, prob = pS_vec)
pE_vec <- c((1-r) / De, r * (1-f) / De, r*f/De, mu,1 - 1 / De - mu)
sample_E <- rmultinom(1, size = E, prob = pE_vec)
pU_vec <- c(1/(beta_1*Dr),delta_1*mu_c,mu,1-1/(beta_1*Dr)-delta_1*mu_c-mu)
sample_U <- rmultinom(1, size = U, prob = pU_vec)
pP_vec <- c(1 / Dr, mu_c,mu, 1 - 1 / Dr - mu-mu_c)
sample_P <- rmultinom(1, size = P, prob = pP_vec)
pF_vec <- c(beta_2 / Dr, mu_c/delta_2,mu,1 -beta_2 / Dr- mu_c/delta_2-mu)
sample_F <- rmultinom(1, size = Fa, prob = pF_vec)
pRU_vec <- c( mu,1-mu)
sample_RU <- rmultinom(1, size = RU, prob = pRU_vec)
pRR_vec <- c(mu,1-mu)
sample_RR <- rmultinom(1, size = RR, prob = pRR_vec)
S_new <- sample_S[3] + lambda*N
E_new <- sample_E[5] + sample_S[1]
U_new <- sample_U[4] + sample_E[1]
P_new <- sample_P[4] + sample_E[2]
F_new <- sample_F[4] + sample_E[3]
RU_new <- sample_RU[2] + sample_U[1]+sample_F[1]
RR_new <- sample_RR[2] + sample_P[1]
DU_new <- DU + sample_U[2]+sample_F[2]
DR_new <- DR + sample_P[2]
est_P_new<- sample_E[2]
est_RR_new<- sample_P[1]
est_DR_new <- sample_P[2]
est_F_new<-sample_E[3]
est_U_new<-sample_E[1]
return(c(S_new, E_new, U_new, P_new, F_new, RU_new, RR_new, DU_new, DR_new,
est_P_new,est_RR_new,est_DR_new,est_F_new,est_U_new))
}
n_period = length(period_start)
which.period <- function(i, phase = period_start){
sum(i >= phase)
}
for(i in 1:length(times)){
stage_pars <- c(b = pars[which.period(i)], r = pars[n_period + which.period(i)])
if(i == 1) {
old_values <- init_obs_current
results = matrix(c(init_obs_current,init_obs_daily,0,0), nrow = 1)
} else {
now_values <- stochastic_sampleR(stage_pars = stage_pars, fix_pars = fix_pars, old_values = old_values)
results = rbind(results, now_values)
old_values <- now_values[1:9]
}
}
return(results)
} |
shapleyValue <- function(game, show.data = FALSE){
agents <- log(length(game)+1)/log(2)
gameDef <- GameTheory::DefineGame(agents, game)
shapley <- shapleyValueInt(gameDef)$SV
shapley <- t(shapley)
if(show.data == TRUE){
rownames(shapley) <- ""
cat(" -----------------------------\n")
cat(" Shapley Value Solution: \n")
cat(" -----------------------------\n")
print(paste0("(", paste(shapley, collapse = ", "), ")"))
}
invisible(shapley)
} |
grnn.parpred <- function(net, x) {
if (class(net) != "General Regression Neural Net") stop("net needs to be a GRNN.", call. = F)
if (is.matrix(x) == F) stop("x needs to be a matrix.", call. = F)
if (anyNA(x) == T) stop("NA found in x.", call. = F)
if (ncol(x) != ncol(net$x)) stop("x dimension is not consistent with grnn.", call. = F)
cls <- parallel::makeCluster(min(floor(nrow(x) / 3), parallel::detectCores() - 1), type = "PSOCK")
obj <- c("net", "x", "grnn.predone", "grnn.predict")
parallel::clusterExport(cls, obj, envir = environment())
spx <- parallel::parLapplyLB(cls, parallel::clusterSplit(cls, seq(nrow(x))),
function(c_) x[c_, ])
rst <- parallel::parLapplyLB(cls, spx, function(x_) grnn.predict(net, x_))
parallel::stopCluster(cls)
return(Reduce(c, rst))
} |
context("curly-curly")
test_that("curly-culry", {
expect_warning(test_collection("curly-curly",
"mixed",
transformer = style_text
), NA)
}) |
dualFlashlight.fn <-
function(result.df, wellName="WELL_USAGE", x.name="mean", y.name="ssmd",
sampleName="Sample", sampleColor="black",
controls = NULL, controlColors = NULL,
xlab="Average Fold Change", ylab="SSMD",
main="Dual-Flashlight Plot", x.legend=NA, y.legend=NA,
cex.point=1, cex.legend = 0.8,
xat=NULL, xMark=NULL, yat=NULL, yMark=NULL, xLines=NULL, yLines=NULL )
{
condt = result.df[,wellName] == sampleName
Legends = sampleName
if( !is.null(controls) ) {
Legends = c(sampleName, controls)
col.legend = c(sampleColor, controlColors)
for( i in 1:length(controls) ) {
condt = condt | result.df[,wellName] == controls[i]
}
}
if( is.na(x.legend) ) x.legend = min(result.df[condt, x.name], na.rm=T)
if( is.na(y.legend) ) y.legend = max(result.df[condt, y.name], na.rm=T)
xRange = range(result.df[condt, x.name], na.rm=T)
yRange = range(result.df[condt, y.name], na.rm=T)
plot( xRange, yRange, type="n", xlab=xlab, ylab=ylab,
cex=cex.point, axes=F, main=main )
if( is.null(xat) ) axis(1) else axis(1, at=xat, labels=xMark )
if( is.null(yat) ) axis(2, las=2) else axis(2, at=yat, labels=yMark, las=2 )
box()
condt = result.df[, wellName ] == sampleName
points(result.df[condt, x.name],
result.df[condt, y.name], col=sampleColor, cex=cex.point)
if( !is.null(controls) ) {
for( i in 1:length(controls) ) {
condt = result.df[, wellName ] == controls[i]
points(result.df[condt, x.name],
result.df[condt, y.name], col=controlColors[i], cex=cex.point)
}
}
if( !is.null(xLines) )
for(a in xLines) lines(rep(a, 2), c(-10000, 10000), col="grey")
if( !is.null(yLines) )
for(a in yLines) lines(c(-10000, 10000), rep(a, 2), col="grey")
legend(x.legend, y.legend, legend=Legends, col=col.legend, cex=cex.legend,
pch=1, bg="white")
} |
.setalphaprob = function (p)
{
if ( p >= 0.51 ) {
alpha <- 1-p
} else {
alpha = p
}
return (alpha)
}
pvalJB = function(R)
{
m2 = centeredmoment(R,2)
m3 = centeredmoment(R,3)
m4 = centeredmoment(R,4)
skew = .skewEst(m3, m2)
exkur = .kurtEst(m4, m2)
JB = ( length(R)/6 )*( skew^2 + (1/4)*(exkur^2) )
out = 1-pchisq(JB,df=2)
}
VaR.Gaussian = function(R,p)
{
alpha = .setalphaprob(p)
columns = ncol(R)
for(column in 1:columns) {
r = as.vector(na.omit(R[,column]))
if (!is.numeric(r)) stop("The selected column is not numeric")
m2 = centeredmoment(r,2)
VaR = - mean(r) - qnorm(alpha)*sqrt(m2)
VaR=array(VaR)
if (column==1) {
result=data.frame(VaR=VaR)
} else {
VaR=data.frame(VaR=VaR)
result=cbind(result,VaR)
}
}
colnames(result)<-colnames(R)
return(result)
}
ES.Gaussian = function(R,p)
{
alpha = .setalphaprob(p)
columns = ncol(R)
for(column in 1:columns) {
r = as.vector(na.omit(R[,column]))
if (!is.numeric(r)) stop("The selected column is not numeric")
m2 = centeredmoment(r,2)
GES = - mean(r) + dnorm(qnorm(alpha))*sqrt(m2)/alpha
GES=array(GES)
if (column==1) {
result=data.frame(GES=GES)
} else {
GES=data.frame(GES=GES)
result=cbind(result,GES)
}
}
colnames(result)<-colnames(R)
return(result)
}
VaR.CornishFisher = function(R,p)
{
alpha = .setalphaprob(p)
z = qnorm(alpha)
columns = ncol(R)
for(column in 1:columns) {
r = as.vector(na.omit(R[,column]))
if (!is.numeric(r)) stop("The selected column is not numeric")
m2 = centeredmoment(r,2)
m3 = centeredmoment(r,3)
m4 = centeredmoment(r,4)
skew = .skewEst(m3, m2)
exkurt = .kurtEst(m4, m2)
h = z + (1/6)*(z^2 -1)*skew + (1/24)*(z^3 - 3*z)*exkurt - (1/36)*(2*z^3 - 5*z)*skew^2
VaR = - mean(r) - h*sqrt(m2)
VaR=array(VaR)
if (column==1) {
result=data.frame(VaR=VaR)
} else {
VaR=data.frame(VaR=VaR)
result=cbind(result,VaR)
}
}
colnames(result)<-colnames(R)
return(result)
}
ES.CornishFisher = function(R,p,c=2)
{
alpha = .setalphaprob(p)
p = alpha
z = qnorm(alpha)
columns = ncol(R)
for(column in 1:columns) {
r = as.vector(na.omit(R[,column]))
if (!is.numeric(r)) stop("The selected column is not numeric")
m2 = centeredmoment(r,2)
m3 = centeredmoment(r,3)
m4 = centeredmoment(r,4)
skew = .skewEst(m3, m2)
exkurt = .kurtEst(m4, m2)
h = z + (1/6)*(z^2 -1)*skew
if(c==2){ h = h + (1/24)*(z^3 - 3*z)*exkurt - (1/36)*(2*z^3 - 5*z)*skew^2};
MES <- dnorm(h) * (1 + h^3 * skew / 6.0 +
(h^6 - 9 * h^4 + 9 * h^2 + 3) * skew^2 / 72 +
(h^4 - 2 * h^2 - 1) * exkurt / 24)
MES = - mean(r) + (sqrt(m2)/p)*MES
MES=array(MES)
if (column==1) {
result=data.frame(MES=MES)
} else {
MES=data.frame(MES=MES)
result=cbind(result,MES)
}
}
colnames(result)<-colnames(R)
return(result)
}
operES.CornishFisher = function(R,p,c=2)
{
alpha = .setalphaprob(p)
p = alpha
z = qnorm(alpha)
columns = ncol(R)
for(column in 1:columns) {
r = as.vector(na.omit(R[,column]))
if (!is.numeric(r)) stop("The selected column is not numeric")
m2 = centeredmoment(r,2)
m3 = centeredmoment(r,3)
m4 = centeredmoment(r,4)
skew = .skewEst(m3, m2)
exkurt = .kurtEst(m4, m2)
h = z + (1/6)*(z^2 -1)*skew
if(c==2){ h = h + (1/24)*(z^3 - 3*z)*exkurt - (1/36)*(2*z^3 - 5*z)*skew^2};
MES <- dnorm(h) * (1 + h^3 * skew / 6.0 +
(h^6 - 9 * h^4 + 9 * h^2 + 3) * skew^2 / 72 +
(h^4 - 2 * h^2 - 1) * exkurt / 24)
MES = - mean(r) - (sqrt(m2))*min( -MES/alpha , h )
MES=array(MES)
if (column==1) {
result=data.frame(MES=MES)
} else {
MES=data.frame(MES=MES)
result=cbind(result,MES)
}
}
colnames(result)<-colnames(R)
return(result)
}
portm2 = function(w,sigma)
{
return(as.numeric(t(w)%*%sigma%*%w))
}
derportm2 = function(w,sigma)
{
return(2*sigma%*%w)
}
portm3 <- function(w, M3)
{
w <- as.numeric(w)
if (NCOL(M3) != 1) M3 <- M3.mat2vec(M3)
.Call('M3port', w, M3, length(w), PACKAGE="PerformanceAnalytics")
}
derportm3 <- function(w, M3)
{
w <- as.numeric(w)
if (NCOL(M3) != 1) M3 <- M3.mat2vec(M3)
as.matrix(.Call('M3port_grad', w, M3, length(w), PACKAGE="PerformanceAnalytics"), ncol = 1)
}
portm4 <- function(w, M4)
{
w <- as.numeric(w)
if (NCOL(M4) != 1) M4 <- M4.mat2vec(M4)
.Call('M4port', w, M4, length(w), PACKAGE="PerformanceAnalytics")
}
derportm4 <- function(w, M4)
{
w <- as.numeric(w)
if (NCOL(M4) != 1) M4 <- M4.mat2vec(M4)
as.matrix(.Call('M4port_grad', w, M4, length(w), PACKAGE="PerformanceAnalytics"), ncol = 1)
}
Portmean = function(w,mu)
{
return( list( t(w)%*%mu , as.vector(w)*as.vector(mu) , as.vector(w)*as.vector(mu)/t(w)%*%mu) )
}
Portsd = function(w,sigma)
{
pm2 = portm2(w,sigma)
dpm2 = derportm2(w,sigma)
dersd = (0.5*as.vector(dpm2))/sqrt(pm2);
contrib = dersd*as.vector(w)
names(contrib) = names(w)
pct_contrib = contrib/sqrt(pm2)
names(pct_contrib) = names(w)
if( abs( sum(contrib)-sqrt(pm2))>0.01*sqrt(pm2)) { print("error")
} else {
ret<-list( sqrt(pm2) , contrib , pct_contrib )
names(ret) <- c("StdDev","contribution","pct_contrib_StdDev")
}
return(ret)
}
VaR.Gaussian.portfolio = function(p,w,mu,sigma)
{
alpha = .setalphaprob(p)
p=alpha
location = sum(w * mu)
pm2 = portm2(w,sigma)
dpm2 = derportm2(w,sigma)
VaR = - location - qnorm(alpha)*sqrt(pm2)
derVaR = - as.vector(mu)- qnorm(alpha)*(0.5*as.vector(dpm2))/sqrt(pm2);
contrib = derVaR*as.vector(w)
names(contrib) = names(w)
pct_contrib = contrib/VaR
names(pct_contrib) = names(w)
if( abs( sum(contrib)-VaR)>0.01*abs(VaR)) { stop("contribution does not add up") } else {
ret<-list( VaR , contrib , pct_contrib )
names(ret) = c("VaR","contribution","pct_contrib_VaR")
}
return(ret)
}
kernel = function( x , h )
{
return( apply( cbind( rep(0,length(x)) , 1-abs(x/h) ) , 1 , 'max' ) );
}
VaR.kernel.portfolio = function( R, p, w )
{
alpha = .setalphaprob(p)
T = dim(R)[1]; N = dim(R)[2];
portfolioreturn = c();
for( t in 1:T ){ portfolioreturn = c( portfolioreturn , sum(w*R[t,]) ) }
bandwith = 2.575*sd(portfolioreturn)/(T^(1/5)) ;
CVaR = c();
VaR = -quantile( portfolioreturn , probs = alpha );
weights = kernel(x= (-VaR-portfolioreturn) , h=bandwith);
correction = VaR/sum(weights*portfolioreturn)
for( i in 1:N ){ CVaR = c( CVaR , sum( weights*R[,i] ) ) }
CVaR = w*CVaR
CVaR = CVaR/sum(CVaR)*VaR
pct_contrib = CVaR/VaR
names(CVaR)<-colnames(R)
names(pct_contrib)<-colnames(R)
ret= list( VaR , CVaR , pct_contrib )
names(ret) = c("VaR","contribution","pct_contrib_VaR")
return(ret)
}
ES.kernel.portfolio= function( R, p, w )
{
VAR<-VaR.kernel.portfolio( R, p, w )
T = dim(R)[1]; N = dim(R)[2];
portfolioreturn = c();
for( t in 1:T ){ portfolioreturn = c( portfolioreturn , sum(w*R[t,]) ) }
PES<-mean(portfolioreturn>VAR$VaR)
}
ES.Gaussian.portfolio = function(p,w,mu,sigma)
{
alpha = .setalphaprob(p)
p=alpha
location = sum(w * mu)
pm2 = portm2(w,sigma)
dpm2 = derportm2(w,sigma)
ES = - location + dnorm(qnorm(alpha))*sqrt(pm2)/alpha
derES = - as.vector(mu) + (1/p)*dnorm(qnorm(alpha))*(0.5*as.vector(dpm2))/sqrt(pm2);
contrib = as.vector(w)*derES;
names(contrib) = names(w)
pct_contrib = contrib/ES
names(pct_contrib) = names(w)
if( abs( sum(contrib)-ES)>0.01*abs(ES)) { stop("contribution does not add up") }
else {
ret = list( ES , contrib , pct_contrib )
names(ret) = c("ES","contribution","pct_contrib_ES")
return(ret)
}
}
VaR.CornishFisher.portfolio = function(p,w,mu,sigma,M3,M4)
{
alpha = .setalphaprob(p)
p=alpha
z = qnorm(alpha)
location = sum(w * mu)
pm2 = portm2(w,sigma)
dpm2 = as.vector( derportm2(w,sigma) )
pm3 = portm3(w,M3)
dpm3 = as.vector( derportm3(w,M3) )
pm4 = portm4(w,M4)
dpm4 = as.vector( derportm4(w,M4) )
skew = .skewEst(pm3, pm2)
exkurt = .kurtEst(pm4, pm2)
derskew = ( 2*(pm2^(3/2))*dpm3 - 3*pm3*sqrt(pm2)*dpm2 )/(2*pm2^3)
derexkurt = ( (pm2)*dpm4 - 2*pm4*dpm2 )/(pm2^3)
h = z + (1/6)*(z^2 -1)*skew
h = h + (1/24)*(z^3 - 3*z)*exkurt - (1/36)*(2*z^3 - 5*z)*skew^2;
MVaR = - location - h*sqrt(pm2)
derh = (z^2 - 1.0) * derskew / 6 + (z^3 - 3 * z) * derexkurt / 24 - (2 * z^3 - 5 * z) * skew * derskew / 18;
derMVaR = -as.vector(mu) - h * as.vector(dpm2) / (2.0 * sqrt(pm2)) - sqrt(pm2) * derh;
contrib = as.vector(w)*as.vector(derMVaR)
pct_contrib = contrib/MVaR
names(contrib) <- names(w)
names(pct_contrib) <- names(w)
if( abs( sum(contrib)-MVaR)>0.01*abs(MVaR)) { stop("contribution does not add up") }
else {
ret=(list( MVaR , contrib, pct_contrib ) )
names(ret) = c("MVaR","contribution","pct_contrib_MVaR")
return(ret)
}
}
derIpower = function(power,h)
{
fullprod = 1;
if( (power%%2)==0 )
{
pstar = power/2;
for(j in c(1:pstar))
{
fullprod = fullprod*(2*j)
}
I = -fullprod*h*dnorm(h);
for(i in c(1:pstar) )
{
prod = 1;
for(j in c(1:i) )
{
prod = prod*(2*j)
}
I = I + (fullprod/prod)*(h^(2*i-1))*(2*i-h^2)*dnorm(h)
}
}else{
pstar = (power-1)/2
for(j in c(0:pstar) )
{
fullprod = fullprod*( (2*j)+1 )
}
I = -fullprod*dnorm(h);
for(i in c(0:pstar) )
{
prod = 1;
for(j in c(0:i) )
{
prod = prod*( (2*j) + 1 )
}
I = I + (fullprod/prod)*(h^(2*i)*(2*i+1-h^2) )*dnorm(h)
}
}
return(I)
}
ES.CornishFisher.portfolio = function(p,w,mu,sigma,M3,M4)
{
alpha = .setalphaprob(p)
p=alpha
z = qnorm(alpha)
location = sum(w * mu)
pm2 = portm2(w,sigma)
dpm2 = as.vector( derportm2(w,sigma) )
pm3 = portm3(w,M3)
dpm3 = as.vector( derportm3(w,M3) )
pm4 = portm4(w,M4)
dpm4 = as.vector( derportm4(w,M4) )
skew = .skewEst(pm3, pm2)
exkurt = .kurtEst(pm4, pm2)
derskew = ( 2*(pm2^(3/2))*dpm3 - 3*pm3*sqrt(pm2)*dpm2 )/(2*pm2^3)
derexkurt = ( (pm2)*dpm4 - 2*pm4*dpm2 )/(pm2^3)
h = z + (1/6)*(z^2 -1)*skew
h = h + (1/24)*(z^3 - 3*z)*exkurt - (1/36)*(2*z^3 - 5*z)*skew^2;
derh = (1/6)*(z^2 -1)*derskew + (1/24)*(z^3 - 3*z)*derexkurt - (1/18)*(2*z^3 - 5*z)*skew*derskew
E <- dnorm(h) * (1 + h^3 * skew / 6.0 +
(h^6 - 9 * h^4 + 9 * h^2 + 3) * skew^2 / 72 +
(h^4 - 2 * h^2 - 1) * exkurt / 24) / alpha
MES = - location + sqrt(pm2)*E
derMES = -mu + E * dpm2 / (2 * sqrt(pm2)) - sqrt(pm2) * E * h * derh + dnorm(h) * sqrt(pm2) / alpha *
(derh * (h^2 * skew / 2 + (6.0 * h^5 - 36 * h^3 + 18 * h) * skew * skew / 72 +
(4 * h^3 - 4 * h) * exkurt / 24) + h^3 * derskew / 6 +
(h^6 - 9 * h^4 + 9 * h^2 + 3) * skew * derskew / 36 + (h^4 - 2 * h^2 - 1) * derexkurt / 24)
contrib = as.vector(w)*as.vector(derMES)
names(contrib) = names(w)
pct_contrib = contrib/MES
names(pct_contrib) = names(w)
if( abs( sum(contrib)-MES)>0.01*abs(MES)) { stop("contribution does not add up") }
else {
ret= list( MES , contrib , pct_contrib)
names(ret) = c("MES","contribution","pct_contrib_MES")
return(ret)
}
}
operES.CornishFisher.portfolio = function(p,w,mu,sigma,M3,M4)
{
alpha = .setalphaprob(p)
p=alpha
z = qnorm(alpha)
location = sum(w * mu)
pm2 = portm2(w,sigma)
dpm2 = as.vector( derportm2(w,sigma) )
pm3 = portm3(w,M3)
dpm3 = as.vector( derportm3(w,M3) )
pm4 = portm4(w,M4)
dpm4 = as.vector( derportm4(w,M4) )
skew = .skewEst(pm3, pm2)
exkurt = .kurtEst(pm4, pm2)
derskew = ( 2*(pm2^(3/2))*dpm3 - 3*pm3*sqrt(pm2)*dpm2 )/(2*pm2^3)
derexkurt = ( (pm2)*dpm4 - 2*pm4*dpm2 )/(pm2^3)
h = z + (1/6)*(z^2 -1)*skew
h = h + (1/24)*(z^3 - 3*z)*exkurt - (1/36)*(2*z^3 - 5*z)*skew^2;
derh = (1/6)*(z^2 -1)*derskew + (1/24)*(z^3 - 3*z)*derexkurt - (1/18)*(2*z^3 - 5*z)*skew*derskew
E <- dnorm(h) * (1 + h^3 * skew / 6.0 +
(h^6 - 9 * h^4 + 9 * h^2 + 3) * skew^2 / 72 +
(h^4 - 2 * h^2 - 1) * exkurt / 24) / alpha
MES = - location - sqrt(pm2)*min(-E,h)
if(-E<=h){
derMES = -mu + E * dpm2 / (2 * sqrt(pm2)) - sqrt(pm2) * E * h * derh + dnorm(h) * sqrt(pm2) / alpha *
(derh * (h^2 * skew / 2 + (6.0 * h^5 - 36 * h^3 + 18 * h) * skew * skew / 72 +
(4 * h^3 - 4 * h) * exkurt / 24) + h^3 * derskew / 6 +
(h^6 - 9 * h^4 + 9 * h^2 + 3) * skew * derskew / 36 + (h^4 - 2 * h^2 - 1) * derexkurt / 24)
} else {
derMES = -mu - 0.5*(dpm2/sqrt(pm2))*h - sqrt(pm2)*derh
}
contrib = as.vector(w)*as.vector(derMES)
names(contrib) = names(w)
pct_contrib = contrib/MES
names(pct_contrib) = names(w)
if( abs( sum(contrib)-MES)>0.01*abs(MES)) { stop("contribution does not add up") }
else {
ret= list( MES , contrib , pct_contrib)
names(ret) = c("MES","contribution","pct_contrib_MES")
return(ret)
}
}
ES.historical = function(R,p) {
alpha = .setalphaprob(p)
for(column in 1:ncol(R)) {
r = na.omit(as.vector(R[,column]))
q = quantile(r,probs=alpha)
exceedr = r[r<q]
hES = (-mean(exceedr))
if(is.nan(hES)){
warning(paste(colnames(R[,column]),"No values less than VaR observed. Setting ES equal to VaR."))
hES=-q
}
hES=array(hES)
if (column==1) {
result=data.frame(hES=hES)
} else {
hES=data.frame(hES=hES)
result=cbind(result,hES)
}
}
colnames(result)<-colnames(R)
return(result)
}
ES.historical.portfolio = function(R,p,w)
{
hvar = as.numeric(VaR.historical.portfolio(R,p,w)$hVaR)
T = dim(R)[1]
N = dim(R)[2]
c_exceed = 0;
r_exceed = 0;
realizedcontrib = rep(0,N);
for(t in c(1:T) )
{
rt = as.vector(R[t,])
rp = sum(w*rt)
if(rp<= -hvar){
c_exceed = c_exceed + 1;
r_exceed = r_exceed + rp;
for( i in c(1:N) ){
realizedcontrib[i] =realizedcontrib[i] + w[i]*rt[i] }
}
}
pct.contrib=as.numeric(realizedcontrib)/r_exceed ;
names(pct.contrib)<-names(w)
ret <- list(-r_exceed/c_exceed,c_exceed,pct.contrib)
names(ret) <- c("-r_exceed/c_exceed","c_exceed","pct_contrib_hES")
return(ret)
}
VaR.historical = function(R,p)
{
alpha = .setalphaprob(p)
for(column in 1:ncol(R)) {
r = na.omit(as.vector(R[,column]))
rq = -quantile(r,probs=alpha)
if (column==1) {
result=data.frame(rq=rq)
} else {
rq=data.frame(rq=rq)
result=cbind(result,rq)
}
}
colnames(result)<-colnames(R)
return(result)
}
VaR.historical.portfolio = function(R,p,w=NULL)
{
alpha = .setalphaprob(p)
rp = Return.portfolio(R,w, contribution=TRUE)
hvar = -quantile(zerofill(rp$portfolio.returns),probs=alpha)
names(hvar) = paste0('hVaR ',100*(1-alpha),"%")
zl<-rp[rp$portfolio.returns<0,]
zl.contrib <- colMeans(zl)[-1]
ratio <- -hvar/sum(colMeans(zl))
zl.contrib <- ratio * zl.contrib
zl.pct.contrib <- (1/sum(zl.contrib))*zl.contrib
ret=list(hVaR = hvar,
contribution = zl.contrib,
pct_contrib_hVaR = zl.pct.contrib)
return(ret)
}
.skewEst <- function(m3, m2) {
if (isTRUE(all.equal(m2, 0.0))) {
return(0.0)
} else {
return(m3 / m2^(3/2))
}
}
.kurtEst <- function(m4, m2) {
if (isTRUE(all.equal(m2, 0.0))) {
return(0.0)
} else {
return(m4 / m2^2 - 3)
}
} |
similar_genres=function(api_key,genre=NA,description=T,urls=T,start=NA,results=15)
{
url=paste("http://developer.echonest.com/api/v4/genre/similar?api_key=",api_key,"&format=json",sep="")
if(results>100)
{
stop("results should be less than or equal to 100")
}
if(!is.na(genre))
{
genre=gsub(" ","+",genre)
url=paste(url,"&name=",genre,sep="")
}
if(description)
{
url=paste(url,"&bucket=description",sep="")
}
if(urls)
{
url=paste(url,"&bucket=urls",sep="")
}
if(!is.na(start))
{
url=paste(url,"&start=",start,sep="")
}
url=paste(url,"&results=",results,sep="")
rd=getURL(url)
rd=fromJSON(rd)
rd$response$genres
} |
knitr::opts_chunk$set(
collapse = TRUE,
comment = "
)
library(rare)
library(Matrix)
dim(data.dtm)
length(data.rating)
hist(colMeans(sign(data.dtm)) * 100, breaks = 50, main = "Histogram of Adjective Rarity in the TripAdvisor Sample",
xlab = "% of Reviews Using Adjective")
par(cex=0.35)
plot(as.dendrogram(data.hc))
set.seed(100)
ts <- sample(1:length(data.rating), 400)
load("vignette_results.RData")
ibest.lambda <- ourfit.cv$ibest[1]
ibest.alpha <- ourfit.cv$ibest[2]
beta.opt <- ourfit$beta[[ibest.alpha]][, ibest.lambda]
gamma.opt <- ourfit$gamma[[ibest.alpha]][, ibest.lambda]
groups.opt <- group.recover(gamma.opt, ourfit$A)
length(groups.opt)
par(cex=0.35)
group.plot(beta.opt, gamma.opt, ourfit$A, data.hc) |
annoPixels <- function(plot, data, type = "box", half = "inherit",
shift = 4, params = NULL, quiet = FALSE, ...) {
errorcheck_annoLoops <- function(hic, loops, half, type, quiet) {
if (!class(hic) %in% c(
"hicSquare", "hicTriangle",
"hicRectangle"
)) {
stop("Input plot must be a plot of class \'hicSquare\', ",
"\'hicTriangle\', or \'hicRectangle\'.", call. = FALSE)
}
if ("data.frame" %in% class(loops) && ncol(loops) < 6) {
stop("Invalid dataframe format. ",
"Dataframe must be in BEDPE format.", call. = FALSE)
}
if ("data.frame" %in% class(loops) && nrow(loops) < 1) {
stop("\'data\' input contains no values.", call. = FALSE)
}
if (!"data.frame" %in% class(loops)) {
if (!is(loops, "GInteractions")) {
if (!file.exists(loops)) {
stop("File", loops, "does not exist.", call. = FALSE)
}
}
}
if (!half %in% c("inherit", "both", "top", "bottom")) {
stop("Invalid \'half\'. Options are \'inherit\',
\'both\', \'top\', or \'bottom\'.", call. = FALSE)
}
if (is(hic, "hicSquare")) {
if (hic$chrom == hic$altchrom) {
if ((hic$half == "top" | hic$half == "bottom") &&
(half == "both")) {
stop("Invalid \'half\' of plot to annotate.",
call. = FALSE
)
}
if (hic$half == "top" & half == "bottom") {
stop("Invalid \'half\' of plot to annotate.",
call. = FALSE
)
}
if (hic$half == "bottom" & half == "top") {
stop("Invalid \'half\' of plot to annotate.",
call. = FALSE
)
}
} else {
if (hic$half == "bottom") {
if (!quiet) {
message("Attempting to annotate pixels where",
hic$chrom, "is on the x-axis and",
hic$altchrom, "is on the y-axis.",
call. = FALSE
)
}
} else if (hic$half == "top") {
if (!quiet) {
message("Attempting to annotate pixels where",
hic$altchrom, "is on the x-axis and",
hic$chrom, "is on the y-axis.",
call. = FALSE
)
}
}
}
} else if (is(hic, "hicTriangle") |
is(hic, "hicRectangle")) {
if (half == "both" | half == "bottom") {
warning("Plot of class \'",
class(hic),
"\' detected. Pixels will automatically be annotated ",
"in the upper triangular of the plot.",
call. = FALSE
)
}
}
if (!type %in% c("box", "circle", "arrow")) {
stop("Invalid \'type\' of annotation. Options are \'box\', ",
"\'circle\', or \'arrow\'.", call. = FALSE)
}
}
subset_loops <- function(hic, loopData, object) {
if (is(hic, "hicTriangle") | is(hic, "hicRectangle")) {
loops_subset <- loopData[which(
loopData[, "chrom1"] == object$chrom &
loopData[, "chrom2"] == object$chrom &
loopData[, "start1"] >= object$chromstart &
loopData[, "end1"] <= object$chromend &
loopData[, "start2"] >= object$chromstart &
loopData[, "end2"] <= object$chromend), ]
} else {
loops_subset <- loopData[which(
loopData[, "chrom1"] == object$chrom &
loopData[, "chrom2"] == object$altchrom &
loopData[, "start1"] >= object$chromstart &
loopData[, "end1"] <= object$chromend &
loopData[, "start2"] >= object$altchromstart &
loopData[, "end2"] <= object$altchromend), ]
}
return(loops_subset)
}
boxAnnotation <- function(df, hic, object, shift, half) {
side <- (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)) +
(2 * shift * hic$resolution)
if (half == "bottom") {
center_x <- 0.5 * (utils::type.convert(df["start2"],
as.is = TRUE) +
utils::type.convert(df["end2"],
as.is = TRUE))
center_y <- 0.5 * (utils::type.convert(df["start1"],
as.is = TRUE) +
utils::type.convert(df["end1"],
as.is = TRUE))
rect1 <- rectGrob(
x = center_x, y = center_y, width = side,
height = side, default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = rect1
),
envir = pgEnv
)
} else if (half == "top") {
center_x <- 0.5 * (utils::type.convert(df["start1"], as.is = TRUE)
+ utils::type.convert(df["end1"], as.is = TRUE))
center_y <- 0.5 * (utils::type.convert(df["start2"], as.is = TRUE)
+ utils::type.convert(df["end2"], as.is = TRUE))
rect1 <- rectGrob(
x = center_x, y = center_y, width = side,
height = side, default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = rect1
),
envir = pgEnv
)
} else if (half == "both") {
center_x1 <- 0.5 * (utils::type.convert(df["start2"], as.is = TRUE)
+ utils::type.convert(df["end2"], as.is = TRUE))
center_y1 <- 0.5 * (utils::type.convert(df["start1"], as.is = TRUE)
+ utils::type.convert(df["end1"], as.is = TRUE))
center_x2 <- 0.5 * (utils::type.convert(df["start1"], as.is = TRUE)
+ utils::type.convert(df["end1"], as.is = TRUE))
center_y2 <- 0.5 * (utils::type.convert(df["start2"], as.is = TRUE)
+ utils::type.convert(df["end2"], as.is = TRUE))
rect1 <- rectGrob(
x = center_x1, y = center_y1, width = side,
height = side, default.units = "native",
gp = object$gp
)
rect2 <- rectGrob(
x = center_x2, y = center_y2, width = side,
height = side, default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = rect1
),
envir = pgEnv
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = rect2
),
envir = pgEnv
)
}
}
circleAnnotation <- function(df, hic, object, shift, half) {
radius <- (0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"],
as.is = TRUE))) +
(shift * hic$resolution)
if (half == "bottom") {
center_x <- 0.5 * (utils::type.convert(df["start2"], as.is = TRUE)
+ utils::type.convert(df["end2"], as.is = TRUE))
center_y <- 0.5 * (utils::type.convert(df["start1"], as.is = TRUE)
+ utils::type.convert(df["end1"], as.is = TRUE))
circ1 <- circleGrob(
x = center_x, y = center_y,
r = radius, default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = circ1
),
envir = pgEnv
)
} else if (half == "top") {
center_x <- 0.5 * (utils::type.convert(df["start1"], as.is = TRUE)
+ utils::type.convert(df["end1"], as.is = TRUE))
center_y <- 0.5 * (utils::type.convert(df["start2"], as.is = TRUE)
+ utils::type.convert(df["end2"], as.is = TRUE))
circ1 <- circleGrob(
x = center_x, y = center_y,
r = radius, default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = circ1
),
envir = pgEnv
)
} else if (half == "both") {
center_x1 <- 0.5 * (utils::type.convert(df["start2"],
as.is = TRUE) +
utils::type.convert(df["end2"],
as.is = TRUE))
center_y1 <- 0.5 * (utils::type.convert(df["start1"],
as.is = TRUE) +
utils::type.convert(df["end1"],
as.is = TRUE))
center_x2 <- 0.5 * (utils::type.convert(df["start1"], as.is = TRUE)
+ utils::type.convert(df["end1"], as.is = TRUE))
center_y2 <- 0.5 * (utils::type.convert(df["start2"], as.is = TRUE)
+ utils::type.convert(df["end2"], as.is = TRUE))
circ1 <- circleGrob(
x = center_x1, y = center_y1,
r = radius, default.units = "native",
gp = object$gp
)
circ2 <- circleGrob(
x = center_x2, y = center_y2,
r = radius, default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = circ1
),
envir = pgEnv
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = circ2
),
envir = pgEnv
)
}
}
arrowAnnotation <- function(df, hic, object, shift, half) {
if (half == "bottom") {
x0 <- utils::type.convert(df["end2"], as.is = TRUE) +
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
y0 <- utils::type.convert(df["start1"], as.is = TRUE) -
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
arrow1 <- segmentsGrob(
x0 = x0, y0 = y0,
x1 = x0 + (shift * hic$resolution),
y1 = y0 - (shift * hic$resolution),
arrow = arrow(
length = unit(0.1, "inches"),
ends = "first",
type = "closed"
),
default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = arrow1
),
envir = pgEnv
)
} else if (half == "top") {
x0 <- utils::type.convert(df["start1"], as.is = TRUE) -
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
y0 <- utils::type.convert(df["end2"], as.is = TRUE) +
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
arrow1 <- segmentsGrob(
x0 = x0, y0 = y0,
x1 = x0 - (shift * hic$resolution),
y1 = y0 + (shift * hic$resolution),
arrow = arrow(
length = unit(0.1, "inches"),
ends = "first",
type = "closed"
),
default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = arrow1
),
envir = pgEnv
)
} else if (half == "both") {
x01 <- utils::type.convert(df["end2"], as.is = TRUE) +
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
y01 <- utils::type.convert(df["start1"], as.is = TRUE) -
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
x02 <- utils::type.convert(df["start1"], as.is = TRUE) -
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
y02 <- utils::type.convert(df["end2"], as.is = TRUE) +
(0.5 * (utils::type.convert(df["end2"], as.is = TRUE) -
utils::type.convert(df["start2"], as.is = TRUE)))
arrow1 <- segmentsGrob(
x0 = x01, y0 = y01,
x1 = x01 + (shift * hic$resolution),
y1 = y01 - (shift * hic$resolution),
arrow = arrow(
length = unit(0.1, "inches"),
ends = "first",
type = "closed"
),
default.units = "native",
gp = object$gp
)
arrow2 <- segmentsGrob(
x0 = x02, y0 = y02,
x1 = x02 - (shift * hic$resolution),
y1 = y02 + (shift * hic$resolution),
arrow = arrow(
length = unit(0.1, "inches"),
ends = "first",
type = "closed"
),
default.units = "native",
gp = object$gp
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = arrow1
),
envir = pgEnv
)
assign("loop_grobs",
addGrob(
gTree = get("loop_grobs", envir = pgEnv),
child = arrow2
),
envir = pgEnv
)
}
}
loopsInternal <- parseParams(
params = params,
defaultArgs = formals(eval(match.call()[[1]])),
declaredArgs = lapply(match.call()[-1], eval.parent, n = 2),
class = "loopsInternal"
)
loopsInternal$gp <- setGP(
gpList = gpar(),
params = loopsInternal, ...
)
loops <- structure(list(
chrom = loopsInternal$plot$chrom,
chromstart = loopsInternal$plot$chromstart,
chromend = loopsInternal$plot$chromend,
altchrom = loopsInternal$plot$altchrom,
altchromstart = loopsInternal$plot$altchromstart,
altchromend = loopsInternal$plot$altchromend,
assembly = loopsInternal$plot$assembly,
x = loopsInternal$plot$x,
y = loopsInternal$plot$y,
width = loopsInternal$plot$width,
height = loopsInternal$plot$height,
just = loopsInternal$plot$just, grobs = NULL
),
class = "pixel"
)
check_page(error = "Cannot annotate Hi-C pixels without a
`plotgardener` page.")
if (is.null(loopsInternal$plot)) stop("argument \"plot\" is missing, ",
"with no default.", call. = FALSE)
if (is.null(loopsInternal$data)) stop("argument \"data\" is missing, ",
"with no default.", call. = FALSE)
errorcheck_annoLoops(
hic = loopsInternal$plot,
loops = loopsInternal$data,
half = loopsInternal$half,
type = loopsInternal$type,
quiet = loopsInternal$quiet
)
half <- loopsInternal$half
if (half == "inherit") {
half <- inherit_half(hic = loopsInternal$plot)
}
if (is(loopsInternal$plot, "hicTriangle") |
is(loopsInternal$plot, "hicRectangle")) {
half <- "top"
}
loopData <- read_pairedData(data = loopsInternal$data,
assembly = loops$assembly,
warning = TRUE)
chromDataAgreement(data = loopData, chrom = loops$chrom,
type = "pairs")
loops_subset <- subset_loops(
hic = loopsInternal$plot, loopData = loopData,
object = loops
)
currentViewports <- current_viewports()
vp_name <- paste0(
"pixel",
length(grep(
pattern = "pixel",
x = currentViewports
)) + 1
)
if (is(loopsInternal$plot, "hicSquare")) {
vp <- viewport(
height = loopsInternal$plot$grobs$vp$height,
width = loopsInternal$plot$grobs$vp$width,
x = loopsInternal$plot$grobs$vp$x,
y = loopsInternal$plot$grobs$vp$y,
clip = "on",
xscale = loopsInternal$plot$grobs$vp$xscale,
yscale = loopsInternal$plot$grobs$vp$yscale,
just = loopsInternal$plot$grobs$vp$justification,
name = vp_name
)
} else if (is(loopsInternal$plot, "hicTriangle")) {
width <- convertUnit(loopsInternal$plot$outsideVP$width,
unitTo = get("page_units", pgEnv), valueOnly = TRUE
)
vp <- viewport(
height = unit(width / sqrt(2), get("page_units", pgEnv)),
width = unit(width / sqrt(2), get("page_units", pgEnv)),
x = loopsInternal$plot$outsideVP$x,
y = loopsInternal$plot$outsideVP$y,
xscale = loopsInternal$plot$grobs$vp$xscale,
yscale = loopsInternal$plot$grobs$vp$yscale,
just = loopsInternal$plot$outsideVP$justification,
name = vp_name,
angle = -45
)
} else if (is(loopsInternal$plot, "hicRectangle")) {
side <- convertUnit(loopsInternal$plot$grobs$vp$width,
unitTo = get("page_units", pgEnv)
)
bottomLeft <- vp_bottomLeft(viewport = loopsInternal$plot$outsideVP)
seekViewport(name = loopsInternal$plot$outsideVP$name)
xCoord <- convertX(unit(loopsInternal$plot$grobs$vp$x),
unitTo = get("page_units", pgEnv)
) + bottomLeft[[1]]
seekViewport(name = "page")
vp <- viewport(
height = side, width = side,
x = xCoord, y = bottomLeft[[2]],
xscale = loopsInternal$plot$grobs$vp$xscale,
yscale = loopsInternal$plot$grobs$vp$yscale,
just = c("left", "bottom"),
name = vp_name,
angle = -45
)
}
assign("loop_grobs", gTree(vp = vp), envir = pgEnv)
if (nrow(loops_subset) > 0) {
if (loopsInternal$type == "box") {
loopsInternal$gp$fill <- NA
invisible(apply(loops_subset, 1, boxAnnotation,
hic = loopsInternal$plot, object = loopsInternal,
shift = loopsInternal$shift, half = half
))
} else if (loopsInternal$type == "circle") {
loopsInternal$gp$fill <- NA
invisible(apply(loops_subset, 1, circleAnnotation,
hic = loopsInternal$plot, object = loopsInternal,
shift = loopsInternal$shift, half = half
))
} else if (loopsInternal$type == "arrow") {
if (is.null(loopsInternal$gp$col) &
is.null(loopsInternal$gp$fill)) {
loopsInternal$gp$fill <- "black"
} else {
if (is.null(loopsInternal$gp$fill)) {
loopsInternal$gp$fill <- loopsInternal$gp$col
}
}
invisible(apply(loops_subset, 1, arrowAnnotation,
hic = loopsInternal$plot, object = loopsInternal,
shift = loopsInternal$shift, half = half
))
}
} else {
warning("No pixels found in region.", call. = FALSE)
}
loops$grobs <- get("loop_grobs", envir = pgEnv)
grid.draw(loops$grobs)
message("pixel[", vp_name, "]")
invisible(loops)
} |
step_text_normalization <-
function(recipe,
...,
role = NA,
trained = FALSE,
columns = NULL,
normalization_form = "nfc",
skip = FALSE,
id = rand_id("text_normalization")) {
recipes::recipes_pkg_check(required_pkgs.step_text_normalization())
add_step(
recipe,
step_text_normalization_new(
terms = enquos(...),
role = role,
trained = trained,
normalization_form = normalization_form,
columns = columns,
skip = skip,
id = id
)
)
}
step_text_normalization_new <-
function(terms, role, trained, columns, normalization_form, skip, id) {
step(
subclass = "text_normalization",
terms = terms,
role = role,
trained = trained,
columns = columns,
normalization_form = normalization_form,
skip = skip,
id = id
)
}
prep.step_text_normalization <- function(x, training, info = NULL, ...) {
col_names <- recipes_eval_select(x$terms, training, info)
training <- factor_to_text(training, col_names)
check_type(training[, col_names], quant = FALSE)
step_text_normalization_new(
terms = x$terms,
role = x$role,
trained = TRUE,
columns = col_names,
normalization_form = x$normalization_form,
skip = x$skip,
id = x$id
)
}
bake.step_text_normalization <- function(object, new_data, ...) {
col_names <- object$columns
new_data <- factor_to_text(new_data, col_names)
normalization_fun <- switch(
object$normalization_form,
nfc = stringi::stri_trans_nfc,
nfd = stringi::stri_trans_nfd,
nfkd = stringi::stri_trans_nfkd,
nfkc = stringi::stri_trans_nfkc,
nfkc_casefold = stringi::stri_trans_nfkc_casefold,
rlang::abort(paste(
"'normalization_form' must be one of",
"'nfc', 'nfd', 'nfkd', 'nfkc', or 'nfkc_casefold'",
"but was ", object$normalization_form
))
)
for (i in seq_along(col_names)) {
new_data[, col_names[i]] <- normalization_fun(
getElement(new_data, col_names[i])
)
}
new_data <- factor_to_text(new_data, col_names)
as_tibble(new_data)
}
print.step_text_normalization <-
function(x, width = max(20, options()$width - 30), ...) {
cat("text_normalizationming for ", sep = "")
printer(x$columns, x$terms, x$trained, width = width)
invisible(x)
}
tidy.step_text_normalization <- function(x, ...) {
if (is_trained(x)) {
res <- tibble(
terms = unname(x$columns),
normalization_form = x$normalization_form
)
} else {
term_names <- sel2char(x$terms)
res <- tibble(
terms = term_names,
normalization_form = na_chr
)
}
res$id <- x$id
res
}
required_pkgs.step_text_normalization <- function(x, ...) {
c("stringi", "textrecipes")
} |
setClass("fitLogNormalDist", slots = c(x = "numeric", n = "numeric", mcmc = "logical"))
setValidity("fitLogNormalDist",
function(object) {
if (length(object@x) == 0) return("'x' slot of 'fitLogNormalDist' object cannot be ignored.")
if (length(object@n) == 0) return("'n' slot of 'fitLogNormalDist' object cannot be ignored.")
if (length(object@mcmc) == 0) return("'mcmc' slot of 'fitLogNormalDist' object cannot be ignored.")
if (any(is.na(object@x))) {
return("NA values in 'x' slot of 'fitLogNormalDist' object.")
}
if (any(object@x <= 0)) return("Negative marker values are not supported by the log-normal distribution.")
else return(TRUE)
}
) |
sampa <- function(x, to = c("ipa", "arpabet")) {
to <- alias_encoding(to)
to <- match.arg(to)
convert_phonetics(x, from = "xsampa", to = to)
}
xsampa <- sampa |
set.semicont <- function(lprec, columns, sc = TRUE)
{
.Call(RlpSolve_set_semicont, lprec, as.integer(columns), as.logical(sc))
invisible()
} |
plot.average_ranks <- function(x, range.first = TRUE, range.col = "black", range.lty = 1, range.lwd = 1, type = "p", ylim = c(nrow(x), 1), xlab = "", ylab = "Average rank", pch = c(16, 3, 3), col = "black", cex = c(1, 1, 1), ...) {
x <- x[order(x$avrg, decreasing = TRUE),]
xaxt <- "n"
matplot(x[,c("avrg", "inf", "sup")], ylim = ylim, ylab = ylab, xaxt = xaxt, xlab = xlab, cex = cex, pch = pch, col = col, type = type, ...)
axis(1, at = 1:nrow(x), labels = row.names(x))
segments(x0 = 1:nrow(x), y0 = x$inf, y1 = x$sup, col = range.col, lty = range.lty, lwd = range.lwd)
if(range.first)
points(x[, "avrg"], pch = pch[1], cex = cex[1], col = col[1], type = type[1])
} |
format_text <- function(text, sep = ", ", last = " and ", width = NULL, ...) {
text_wrap(text_concatenate(text, sep = sep, last = last), width = width)
}
text_fullstop <- function(text) {
text[!text_lastchar(text) %in% c(".", ":", ",", ";", "!", "?")] <- paste0(text[text_lastchar(text) != "."], ".")
text
}
text_lastchar <- function(text, n = 1) {
sapply(text, function(xx) {
substr(xx, (nchar(xx) - n + 1), nchar(xx))
})
}
text_concatenate <- function(text, sep = ", ", last = " and ") {
text <- text[text != ""]
if (length(text) == 1) {
text
} else {
s <- paste0(utils::head(text, -1), collapse = sep)
s <- paste0(c(s, utils::tail(text, 1)), collapse = last)
s
}
}
text_paste <- function(text, text2 = NULL, sep = ", ", ...) {
if (!is.null(text2)) {
paste0(text, ifelse(text == "" | text2 == "", "", sep), text2)
}
}
text_remove <- function(text, pattern = "", ...) {
gsub(pattern, "", text, ...)
}
text_wrap <- function(text, width = NULL, ...) {
if (is.null(width)) {
return(text)
}
text <- strsplit(text, "\n", perl = TRUE)
text <- unlist(text)
if (width == "auto") {
width <- 0.9 * getOption("width")
}
wrapped <- ""
for (s in text) {
if (nchar(s) > width) {
leading_spaces <- nchar(s) - nchar(trimws(s))
s <- strwrap(s, width = width)
s <- paste0(s, collapse = "\n")
s <- paste0(paste0(rep(" ", leading_spaces), collapse = ""), s)
}
wrapped <- paste0(wrapped, s, "\n")
}
wrapped
} |
check_factors <- function(df_cat){
if("factor" %in% sapply(df_cat, class)){
are_lvls_unq <- function(fct){
if(class(fct) == "factor"){
return(!length(levels(fct)) == length(unique(levels(fct))))
} else {
return(FALSE)
}
}
non_unq <- which(sapply(df_cat, are_lvls_unq))
if(length(non_unq) > 0){
for(i in 1:length(non_unq)){
levels(df_cat[, non_unq[i]]) <- unique(levels(df_cat[, non_unq[i]]))
warning(paste0("Dropping duplicate levels found in ", names(df_cat[non_unq[i]])))
}
}
}
return(df_cat)
} |
context("objects")
test_that("the length of a Python object can be computed", {
skip_if_no_python()
m <- py_eval("[1, 2, 3]", convert = FALSE)
expect_equal(length(m), 3L)
x <- py_eval("None", convert = FALSE)
expect_identical(length(x), 0L)
expect_identical(py_bool(x), FALSE)
expect_error(py_len(x), "'NoneType' has no len()")
x <- py_eval("object()", convert = FALSE)
expect_identical(length(x), 1L)
expect_identical(py_bool(x), TRUE)
expect_error(py_len(x), "'object' has no len()")
})
test_that("python objects with a __setitem__ method can be used", {
skip_if_no_python()
library(reticulate)
py_run_string('
class M:
def __getitem__(self, k):
return "M"
')
m <- py_eval('M()', convert = TRUE)
expect_equal(m[1], "M")
m <- py_eval('M()', convert = FALSE)
expect_equal(m[1], r_to_py("M"))
}) |
mlweibull <- function(x, na.rm = FALSE, ...) {
if (na.rm) x <- x[!is.na(x)] else assertthat::assert_that(!anyNA(x))
ml_input_checker(x)
assertthat::assert_that(min(x) > 0)
dots <- list(...)
shape0 <- if (!is.null(dots$sigma0)) dots$shape0 else 1
rel.tol <- if (!is.null(dots$rel.tol)) {
dots$rel.tol
} else {
.Machine$double.eps^0.25
}
iterlim <- if (!is.null(dots$iterlim)) dots$iterlim else 100
log_x <- log(x)
l_hat <- mean(log_x)
log_xsq <- log_x^2
for (i in 1:iterlim) {
shape0_lsum <- mean(x^shape0 * log_x)
shape0_lsum_sqr <- mean(x^shape0 * log_xsq)
shape0_sum <- mean(x^shape0)
A <- shape0_lsum / shape0_sum
B <- shape0_lsum_sqr / shape0_sum
top <- 1 / shape0 + l_hat - A
bottom <- -1 / shape0^2 + A^2 - B
shape <- shape0 - top / bottom
if (abs((shape0 - shape) / shape0) < rel.tol) break
shape0 <- shape
}
if (i == iterlim) {
warning(paste0(
"The iteration limit (iterlim = ", iterlim, ") was reached",
" before the relative tolerance requirement (rel.tol = ",
rel.tol, ")."
))
}
scale <- (mean(x^shape))^(1 / shape)
shape_sum <- mean(x^shape)
n <- length(x)
object <- c(shape = shape, scale = scale)
class(object) <- "univariateML"
attr(object, "model") <- "Weibull"
attr(object, "density") <- "stats::dweibull"
attr(object, "logLik") <- n * (log(shape) - log(scale) +
(shape - 1) * (l_hat - log(scale)) - scale^-shape * shape_sum)
attr(object, "support") <- c(0, Inf)
attr(object, "n") <- length(x)
attr(object, "call") <- match.call()
object
} |
context("test get_event_stats_for_account is working")
test_that('function fails if no key has been set', {
testthat::skip_on_cran()
testthat::skip_on_travis()
expect_error(get_event_stats_for_account(eventid = 65006,
accountid = 89550641,
language = 'en',
key = NULL),
'The function cannot find an API key.')
key_actions('register_key', Sys.getenv('RDota_KEY'))
expect_error(get_event_stats_for_account(eventid = 65006,
accountid = 89550641,
language = 'en',
key = NULL),
NA)
expect_true(grepl('GetEventStatsForAccount',
get_event_stats_for_account(eventid = 65006, accountid = 89550641)$url))
expect_equal(get_event_stats_for_account(eventid = 65006,
accountid = 89550641)$response$status_code,
200L)
expect_identical(
get_event_stats_for_account(eventid = 65006,
accountid = 89550641)$response$request$options$useragent,
'http://github.com/lyzander/RDota2'
)
expect_true(is.list(get_event_stats_for_account(eventid = 65006, accountid = 89550641)$content))
key_actions('delete_key')
}) |
binom.length <- function(p, n, conf.level = 0.95, method = "all", ...) {
expect.length <- function(ci, x, n, p)
sum((ci$upper - ci$lower) * dbinom(x, n, p))
params <- expand.grid(p = p, n = n)
len <- vector("list", NROW(params))
for(i in seq(NROW(params))) {
p.i <- params$p[i]
n.i <- params$n[i]
x <- 0:n.i
if(is.function(method)) {
ci <- method(x, n.i, conf.level, ...)
} else {
ci <- binom.confint(x, n.i, conf.level, method, ...)
}
ci <- split(ci[c("lower", "upper")], ci$method)
expect <- lapply(ci, expect.length, x, n.i, p.i)
len[[i]] <- data.frame(method = names(expect))
len[[i]]$n <- n.i
len[[i]]$p <- p.i
len[[i]]$length <- unlist(expect)
}
len <- do.call("rbind", len)
row.names(len) <- seq(NROW(len))
len
} |
visual <-
function(x, ...){
UseMethod("visual")
} |
pbd_loglik_rhs = function(t,x,pars)
{
b = pars[[1]](t,as.numeric(pars[5:length(pars)]))
mu_g = pars[[2]](t,as.numeric(pars[5:length(pars)]))
la2 = pars[[3]](t,as.numeric(pars[5:length(pars)]))
mu_i = pars[[4]](t,as.numeric(pars[5:length(pars)]))
nu2 = la2 + mu_i
H = x[1]
p_i = x[2]
q_i = x[3]
q_g = x[4]
dH = -H * b * (1 - p_i)
dp_i = -(nu2 + b) * p_i + la2 * q_g + mu_i + b*p_i^2
dq_i = -(nu2 + b) * q_i + la2 * q_g + mu_i + b*q_i^2
dq_g = -(mu_g + b) * q_g + mu_g + b*q_i*q_g
dx = c(dH,dp_i,dq_i,dq_g)
return(list(dx))
} |
`labels<-` <- function(object, ..., value) {
UseMethod("labels<-")
}
`labels<-.default` <- function(object, ..., value) {
if (length(value) < length(object)) {
warning("The lengths of the new labels is shorter than the length of the object - labels are recycled.")
names(object) <- rep(value, length.out = length(object))
} else {
names(object) <- value
}
object
}
`labels<-.dendrogram` <- function(object, ..., value) {
if (missing(value)) {
if (dendextend_options("warn")) warning("value is missing, returning the dendrogram as is")
return(object)
}
new_labels <- value
new_labels_length <- length(new_labels)
leaves_length <- nleaves(object)
if (new_labels_length < leaves_length) {
warning("The lengths of the new labels is shorter than the number of leaves in the dendrogram - labels are recycled.")
new_labels <- rep(new_labels, length.out = leaves_length)
}
.change.label.LTR <- function(dend_node) {
if (is.leaf(dend_node)) {
attr(dend_node, "label") <- new_labels[i_leaf_number]
i_leaf_number <<- i_leaf_number + 1
}
return(unclass(dend_node))
}
i_leaf_number <- 1
new_dend_object <- dendrapply(object, .change.label.LTR)
class(new_dend_object) <- "dendrogram"
return(new_dend_object)
}
labels.hclust <- function(object, order = TRUE, ...) {
if (order) {
labels_obj <- as.character(object$labels[object$order])
} else {
labels_obj <- as.character(object$labels)
}
return(labels_obj)
}
`labels<-.hclust` <- function(object, ..., value) {
if (length(value) < length(object$labels)) {
warning("The lengths of the new labels is shorter than the number of leaves in the hclust - labels are recycled.")
}
object$labels[object$order] <- value
return(object)
}
labels.phylo <- function(object, ...) {
object$tip.label
}
`labels<-.phylo` <- function(object, ..., value) {
if (missing(value)) {
if (dendextend_options("warn")) warning("value is missing, returning the dendrogram as is")
return(object)
}
new_labels <- as.character(value)
new_labels_length <- length(new_labels)
leaves_length <- nleaves(object)
if (new_labels_length < leaves_length) {
warning("The lengths of the new labels is shorter than the number of leaves in the dendrogram - labels are recycled.")
new_labels <- rep(new_labels, length.out = leaves_length)
}
object$tip.label <- new_labels
return(object)
}
`order.dendrogram<-` <- function(object, ..., value) {
if (!is.numeric(value)) {
warning("'value' is not numeric - coerced using as.numeric")
value <- as.numeric(value)
}
if (!is.integer(value)) {
warning("'value' is not integer - coerced using as.integer")
value <- as.integer(value)
}
new_order_values <- value
new_labels_length <- length(new_order_values)
leaves_length <- nleaves(object)
if (new_labels_length < leaves_length) {
warning("The lengths of the new labels is shorter than the number of leaves in the dendrogram - labels are recycled.")
new_order_values <- rep(new_order_values, length.out = leaves_length)
}
if (any(duplicated(new_order_values))) {
warning("The value you wish to insert into the dendrogram 'objects' has duplicate values. Often you are likely to prefer unique values in your vector. So be sure to check that you've used the correct vector here...")
}
.change_order_LTR <- function(dend_node) {
if (is.leaf(dend_node)) {
attr_backup <- attributes(dend_node)
dend_node <- new_order_values[i_leaf_number]
attributes(dend_node) <- attr_backup
i_leaf_number <<- i_leaf_number + 1
}
return(unclass(dend_node))
}
i_leaf_number <- 1
new_dend_object <- dendrapply(object, .change_order_LTR)
class(new_dend_object) <- "dendrogram"
return(new_dend_object)
}
order.hclust <- function(x, ...) {
if (!is.hclust(x)) stop("x is not a hclust object.")
x$order
}
set_labels <- function(dend, labels, ...) {
labels(dend) <- labels
dend
}
place_labels <- function(dend, labels, ...) {
set_labels(dend, labels[order.dendrogram(dend)])
} |
MiIntDepthAjust <- function(Matrix, specimens, test.frac = 5, times = 5,
ntrees = 1000, shrinkage = 0.1, intdepth = c(1:4),
n.terminal=10, bag.frac=0.5){
Data <- as.data.frame(t(Matrix))
accur.train.data <- data.frame(); accur.test.data <- data.frame()
for(j in 1:times) {
idx <- sample(1:length(specimens), size = length(specimens)/test.frac)
idx<-round(idx)
train.data <- Data[-idx, ]; test.data <- Data[idx, ]
train.group <- specimens[-idx]; test.group <- specimens[idx]
accur.train <- c(); accur.test <- c();
for (i in 1:length(intdepth)){
Model <- gbm::gbm(train.group~., train.data, distribution = "gaussian",
n.trees = ntrees, shrinkage = shrinkage, interaction.depth = intdepth [i],
n.minobsinnode = n.terminal, bag.fraction = bag.frac)
Pred <- stats::predict(Model, test.data, n.trees = ntrees)
Pred <- round(Pred); Pred <- factor(Pred, levels = c(1,2), labels = levels(train.group))
accur.test[i] <- 1-mean(test.group != Pred)
Model.fit <- round(Model$fit)
Model.fit <- factor(Model.fit, levels = c(1,2), labels = levels(train.group))
accur.train[i] <- 1-mean(train.group != Model.fit)
}
accur.train.data <- rbind(accur.train.data, accur.train);
accur.test.data <- rbind(accur.test.data, accur.test)
}
colnames(accur.train.data) <- intdepth; colnames(accur.test.data) <- intdepth
accur.train.median <- apply(accur.train.data, 2, stats::median, na.rm = T)
accur.test.median <- apply(accur.test.data, 2, stats::median, na.rm = T)
accur.train.data <- rbind(accur.train.data, accur.train.median);
rownames(accur.train.data)<-c(paste("Trial", 1:times, sep=""), "Median")
accur.test.data <- rbind(accur.test.data, accur.test.median)
rownames(accur.test.data)<-c(paste("Trial", 1:times, sep=""), "Median")
int.depth.res <- list("train.accuracy" = accur.train.data, "test.accuracy" = accur.test.data)
graphics::plot(x=intdepth, y=seq(from=0.2, to=1.2, length=length(intdepth)), type = "n", xlab="Maximum depth of each tree", ylab = "Accuracy")
graphics::lines(intdepth, accur.train.median, type = "o", col = 4, lwd = 1.8)
graphics::lines(intdepth, accur.test.median, type = "o", col = 2, lwd = 1.8)
graphics::legend(x = "topright", legend = c("Train", "Test"), col = c(4,2), pch=1)
return(int.depth.res)
} |
generate_response <- function(data, sim_args, keep_intermediate = TRUE, ...) {
outcome_name <- parse_formula(sim_args)[['outcome']]
outcome_type <- sim_args[['outcome_type']]
fixed_formula <- parse_formula(sim_args)[['fixed']]
fixed_vars <- attr(terms(fixed_formula),"term.labels")
if(any(grepl('^factor\\(', fixed_vars))) {
fixed_vars <- gsub("factor\\(|\\)$", "", fixed_vars)
}
if(any(grepl('^ns\\(', fixed_vars))) {
fixed_vars <- gsub("ns\\(|\\,.+\\)$", "", fixed_vars)
}
if(any(grepl("^poly\\(", fixed_vars))) {
fixed_vars <- gsub("poly\\(|\\,.+\\)", "", fixed_vars)
}
if(any(grepl("^ns|^poly", attr(terms(fixed_formula), "term.labels")))) {
fixed_vars <- poly_ns_names(sim_args)
}
if(any(unlist(lapply(seq_along(sim_args[['fixed']]), function(xx)
sim_args[['fixed']][[xx]]$var_type)) == 'factor')) {
num_levels <- lapply(seq_along(sim_args[['fixed']]), function(xx)
sim_args[['fixed']][[xx]][['levels']])
num_levels <- purrr::modify_if(num_levels, is.character, length)
if(any(unlist(lapply(seq_along(sim_args[['fixed']]), function(xx)
num_levels[[xx]] > 1 &
sim_args[['fixed']][[xx]][['var_type']] == 'factor'))
)) {
fixed_vars <- factor_names(sim_args, fixed_vars)
}
}
if(any(grepl(':', fixed_vars))) {
fixed_vars <- gsub(":", "\\.", fixed_vars)
}
Xmat <- dplyr::select(data, dplyr::all_of(fixed_vars))
if(any(grepl('Intercept', names(data)))) {
Xmat <- cbind(data['X.Intercept.'], Xmat)
}
fixed_outcome <- as.matrix(Xmat) %*% sim_args[['reg_weights']]
if(length(parse_formula(sim_args)[['randomeffect']]) != 0) {
random_formula <- parse_formula(sim_args)[['randomeffect']]
random_formula_parsed <- parse_randomeffect(random_formula)
random_effects_names <- names(sim_args[['randomeffect']])
random_formula <- lapply(seq_along(random_formula_parsed[['random_effects']]), function(xx)
as.formula(random_formula_parsed[['random_effects']][xx]))
Zmat <- lapply(random_formula, model.matrix, data = data) %>%
lapply(., data.frame)
cross_class <- parse_crossclass(sim_args, parse_randomeffect(parse_formula(sim_args)[['randomeffect']]))
if(any(cross_class[['cross_class_re']])){
Zmat <- do.call('cbind', Zmat)
} else {
Zmat <- dplyr::bind_cols(Zmat)
}
rand_effects <- dplyr::select(data, random_effects_names)
random_effects <- rowSums(rand_effects * Zmat)
} else {
random_effects <- NULL
random_effects <- 0
}
if(keep_intermediate) {
response_outcomes <- data.frame(
fixed_outcome = fixed_outcome,
random_effects = random_effects
)
data <- cbind(data, response_outcomes, row.names = NULL)
}
if(is.null(data[['error']])) {
data['error'] <- 0
}
outcome <- as.numeric(unlist(fixed_outcome + random_effects + data['error']))
if(!is.null(sim_args[['outcome_type']])){
trans_outcome <- transform_outcome(outcome, type = sim_args[['outcome_type']])
data <- cbind(data, untransformed_outcome = outcome)
data[outcome_name] <- trans_outcome
} else {
data[outcome_name] <- outcome
}
data
} |
df <- data(iris)
head(iris)
ran <- sample(1:nrow(iris), 0.9 * nrow(iris))
ran
nor <-function(x) { (x -min(x))/(max(x)-min(x)) }
nor
iris_norm <- as.data.frame(lapply(iris[,c(1,2,3,4)], nor))
head(iris_norm)
summary(iris_norm)
iris_train <- iris_norm[ran,]
head(iris_train)
iris_test <- iris_norm[-ran,]
head(iris_test)
iris_target_category <- iris[ran,5]
iris_test_category <- iris[-ran,5]
library(class)
pr <- knn(train=iris_train,test=iris_test,cl=iris_target_category,k=13)
tab <- table(pr,iris_test_category)
tab
accuracy <- function(x){sum(diag(x)/(sum(rowSums(x)))) * 100}
accuracy(tab) |
"childMortality" |
GetDOIs <- function(bib){
missing.dois.pos <- which(if (length(bib) == 1)
is.null(bib$doi)
else vapply(bib$doi, is.null, FALSE))
if (!length(missing.dois.pos))
message("All entries already have DOIs")
else{
json.bib <- toJSON(FormatEntryForCrossRef(bib[[missing.dois.pos]]))
headers <- list('Accept' = 'application/json',
'Content-Type' = 'application/json')
json.res <- httr::POST("https://search.crossref.org/links", body = json.bib,
config = list(add_headers = headers),
encode = "json")
status <- status_code(json.res)
if (status != 200 ||
!(json.res <- content(json.res, type = "application/json",
encoding = "UTF-8"))[[2L]])
message(gettextf("Failed to retrieve any DOIs [%s].", status))
else{
matches <- vapply(json.res[[1L]], "[[", FALSE, "match")
if (!any(matches))
message("No matches.")
else{
match.str <- paste0(missing.dois.pos[matches], collapse = ", ")
message(gettextf("Matches for entries at positions %s.",
match.str))
bib$doi[missing.dois.pos[matches]] <- sub("https?://(dx\\.)?doi.org/", "",
vapply(json.res[[1L]][matches], "[[",
"",
"doi"),
useBytes = TRUE)
}
}
}
bib
}
FormatEntryForCrossRef <- function(bib){
fmt.env <- MakeBibLaTeX("text", TRUE)
assign("bib", bib, envir = fmt.env)
with(fmt.env, {
bibstyle <- "authoryear"
collapse <- function(strings)
paste(strings, collapse = " ")
fmtVolume <- function(vol, num){
if (length(vol)){
res <- paste0("vol. ", vol)
if (length(num))
res <- paste(res, num, sep = ', no. ')
res
}
}
fmtJTitle <- function(title){
if (grepl('[.?!]$', title, useBytes = TRUE))
paste0("\"", collapse(cleanupLatex(title)), "\"")
else paste0("\"", collapse(cleanupLatex(title)), "\".")
}
fmtJournal <- function(s){
if (length(s$journaltitle)){
res <- cleanupLatex(s$journaltitle)
if (length(s$journalsubtitle))
res <- paste(addPeriod(res), cleanupLatex(s$journalsubtitle))
return(res)
}else if(!is.null(s$journal)){
cleanupLatex(s$journal)
}
}
formatArticle <- function(paper){
collapse(c(fmtBAuthor(paper), fmtJTitle(paper$title),
sentence(fmtJournal(paper),
fmtVolume(paper$volume, paper$number),
fmtPages(paper$pages, paper$pagination),
fmtDate(attr(paper, "dateobj")), sep = ', '),
fmtISSN(paper$issn)))
}
oldopts <- BibOptions(max.names = 99, first.inits = TRUE)
on.exit(BibOptions(oldopts))
vapply(unclass(bib), function(doc){
doc$.duplicated <- FALSE
formatArticle(doc)
}, "")
})
} |
"arnold1949"
"intcal09"
"intcal13"
"intcal20" |
setMethodS3("callXXorXY", "numeric", function(betaX, betaY=NULL, flavor=c("density"), adjust=1.5, ..., censorAt=c(-0.5,+1.5), verbose=FALSE) {
betaX <- as.double(betaX);
if (!is.null(betaY)) {
betaY <- as.double(betaY);
}
flavor <- match.arg(flavor);
adjust <- as.double(adjust);
if (length(adjust) != 1) {
stop("Argument 'adjust' must be single value: ", adjust);
}
if (adjust <= 0) {
stop("Argument 'adjust' must be positive: ", adjust);
}
censorAt <- Arguments$getDoubles(censorAt, length=c(2,2));
verbose <- Arguments$getVerbose(verbose);
if (verbose) {
pushState(verbose);
on.exit(popState(verbose));
}
verbose && enter(verbose, "Calling gender from allele B fractions (BAFs)");
betaT <- betaX;
betaT[betaT < censorAt[1]] <- -Inf;
betaT[betaT > censorAt[2]] <- +Inf;
betaT <- betaT[is.finite(betaT)];
fit <- .findPeaksAndValleys(betaT, adjust=adjust, ...);
isXYByChrX <- (sum(fit$type == "peak") == 2);
if (isXYByChrX && (length(betaY) > 100)) {
betaT <- betaY;
betaT[betaT < censorAt[1]] <- -Inf;
betaT[betaT > censorAt[2]] <- +Inf;
fit <- .findPeaksAndValleys(betaT, adjust=adjust, ...);
isXYByChrY <- (sum(fit$type == "peak") == 2);
if (isXYByChrY != isXYByChrX) {
throw("Allele B fractions for ChrX and ChrY are inconsistent.");
}
}
res <- ifelse(isXYByChrX, "XY", "XX");
verbose && exit(verbose);
res;
}) |
nato_defense_expenditure_path <- '/tmp/PR-2019-069-eng.xlsx'
download.file(
'https://www.nato.int/docu/pr/2019/PR-2019-069-eng.xlsx',
nato_defense_expenditure_path,
method = 'curl'
)
df_list <- readxl::excel_sheets(nato_defense_expenditure_path)[c(-1, -4)] %>%
map(~{
df = readxl::read_excel(
nato_defense_expenditure_path,
sheet = .x, skip = if (grepl('5|7', .x)) 18 else 6,
na = '..'
)
if (grepl('5', .x)) {
df[1, 1] <- 'Real GDP (2015 prices)'
}
if (grepl('7', .x)) {
df[1, 1] <- 'Military personnel (thousands)'
}
df
})
nato <- df_list %>%
map_dfr(function(df) {
df %>%
filter(!is.na(`...2`) | rowSums(!is.na(.)) == 1, rowSums(!is.na(.)) > 0) %>%
fill(`...1`) %>%
filter(!is.na(`2012`)) %>%
rename(variable = `...1`, country_stanag = `...2`) %>%
mutate(country_stanag = parse_country(country_stanag, to = 'stanag')) %>%
gather(year, value, -1:-2) %>%
mutate(year = as.integer(parse_number(year)))
}) %>%
spread(variable, value)
nato$`Real GDP (2015 prices)` <- nato$`Real GDP (2015 prices)` * 1000000000L
nato$`GDP per capita (thousand US dollars)` <- nato$`GDP per capita (thousand US dollars)` * 1000L
nato$`Military personnel (thousands)` <- round(nato$`Military personnel (thousands)` * 1000L)
nato$`Current prices and exchange rates` <- nato$`Current prices and exchange rates` * 1000000L
nato$`Constant 2015 prices and exchange rates` <- nato$`Constant 2015 prices and exchange rates` * 1000000L
names(nato) <- c(
"country_stanag", "year",
"Defense expenditure annual real change (% GDP)",
"Defense expenditure (USD, 2015 prices)",
"Defense expenditure (USD, current prices)",
"Defence expenditure per capita (USD)",
"Equipment expenditure (%)", "GDP per capita (USD)",
"Infrastructure expenditure (%)",
"Military personnel",
"Other expenditure (%)", "Personnel expenditure (%)",
"Real GDP (2015 prices)", "Defense expenditure (% real GDP)"
)
nato <- nato[, c(1, 2, 5, 4, 14, 3, 13, 8, 6, 10, 7, 12, 9, 11)]
usethis::use_data(nato, overwrite = TRUE) |
cqr.fit=function(X,y,tau,beta,method,maxit,toler,rho)
{
if(missing(method)){
cat("please input the method\n")
method=1
}
if(method=="mm")
return(cqr.mm(X,y,tau,beta,maxit,toler))
if(method=="cd")
return(cqr.cd(X,y,tau,beta,maxit,toler))
if(method=="ip")
return(cqr.ip(X,y,tau))
if(method=="admm")
return(cqr.admm(X,y,tau,rho,beta,maxit,toler))
} |
rsdmxLogger <- R6Class("rsdmxLogger",
private = list(
enabled = FALSE,
logger = function(type, text){
if(private$enabled) cat(sprintf("[rsdmx][%s] %s \n", type, text))
}
),
public = list(
INFO = function(text){private$logger("INFO", text)},
WARN = function(text){private$logger("WARN", text)},
ERROR = function(text){private$logger("ERROR", text)},
initialize = function(enabled = TRUE){
private$enabled <- enabled
}
)
) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.