Logic {base}  R Documentation 
These operators act on raw, logical and numberlike vectors.
! x
x & y
x && y
x  y
x  y
xor(x, y)
isTRUE (x)
isFALSE(x)
x, y 

!
indicates logical negation (NOT).
&
and &&
indicate logical AND and 
and 
indicate logical OR. The shorter forms performs elementwise
comparisons in much the same way as arithmetic operators. The longer
forms evaluates left to right, proceeding only until the result is
determined. The longer form is appropriate for programming
controlflow and typically preferred in if
clauses.
Using vectors of more than one element in &&
or 
will
give a warning (as from R 4.2.0), or an error if the environment
variable _R_CHECK_LENGTH_1_LOGIC2_ is set to a true value (this
is intended to become the default in future).
xor
indicates elementwise exclusive OR.
isTRUE(x)
is the same as
{ is.logical(x) && length(x) == 1 && !is.na(x) && x }
;
isFALSE()
is defined analogously. Consequently,
if(isTRUE(cond))
may be preferable to if(cond)
because
of NA
s.
In earlier R versions, isTRUE < function(x) identical(x, TRUE)
,
had the drawback to be false e.g., for x < c(val = TRUE)
.
Numeric and complex vectors will be coerced to logical values, with
zero being false and all nonzero values being true. Raw vectors are
handled without any coercion for !
, &
, 
and
xor
, with these operators being applied bitwise (so !
is
the 1scomplement).
The operators !
, &
and 
are generic functions:
methods can be written for them individually or via the
Ops
(or S4 Logic
, see below)
group generic function. (See Ops
for
how dispatch is computed.)
NA
is a valid logical object. Where a component of
x
or y
is NA
, the result will be NA
if the
outcome is ambiguous. In other words NA & TRUE
evaluates to
NA
, but NA & FALSE
evaluates to FALSE
. See the
examples below.
See Syntax for the precedence of these operators: unlike many other languages (including S) the AND and OR operators do not have the same precedence (the AND operators have higher precedence than the OR operators).
For !
, a logical or raw vector(for raw x
) of the same
length as x
: names, dims and dimnames are copied from x
,
and all other attributes (including class) if no coercion is done.
For 
, &
and xor
a logical or raw vector. If
involving a zerolength vector the result has length zero. Otherwise,
the elements of shorter vectors are recycled as necessary (with a
warning
when they are recycled only fractionally).
The rules for determining the attributes of the result are rather
complicated. Most attributes are taken from the longer argument, the
first if they are of the same length. Names will be copied from the
first if it is the same length as the answer, otherwise from the
second if that is. For time series, these operations are allowed only
if the series are compatible, when the class and tsp
attribute of whichever is a time series (the same, if both are) are
used. For arrays (and an array result) the dimensions and dimnames
are taken from first argument if it is an array, otherwise the second.
For 
, &&
and isTRUE
, a lengthone logical vector.
!
, &
and 
are S4 generics, the latter two part
of the Logic
group generic (and
hence methods need argument names e1, e2
).
The elementwise operators are sometimes called as functions as
e.g. `&`(x, y)
: see the description of how
argumentmatching is done in Ops
.
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language. Wadsworth & Brooks/Cole.
any
and all
for OR and AND on many scalar
arguments.
Syntax
for operator precedence.
bitwAnd
for bitwise versions for integer vectors.
y < 1 + (x < stats::rpois(50, lambda = 1.5) / 4  1)
x[(x > 0) & (x < 1)] # all x values between 0 and 1
if (any(x == 0)  any(y == 0)) "zero encountered"
## construct truth tables :
x < c(NA, FALSE, TRUE)
names(x) < as.character(x)
outer(x, x, `&`) ## AND table
outer(x, x, ``) ## OR table