The 3 Rs – Arithmetic

You can think of R as like a giant calculator. It has a great capacity for mathematical operations. In this article I’ll look at some of the more basic ones, to give a flavour of what basic arithmetic you can do.

In the main your arithmetic is going to involve adding up, dividing, subtracting and multiplication. These things are all carried out using basic operators that are familiar to everyone: + – * / and ().

The order of the operators is important. R will evaluate your maths in a set order. multiplication (*) and division (/) are evaluated first. Then addition (+) and subtraction (-). As well as this basic order, things inside parentheses () will be evaluated before anything “outside” the parentheses (still in the */+- order). So, remember this running order when you type your maths e.g.

7 + 4 * 11
[1] 51

(7 + 4) * 11
[1] 121

As well as the basic operators there are some “extras”.

Powers (i.e. exponents) are designated using the caret (^) character. These are evaluated before any of the other operators. For example:

2^2 ; 2^3 ; 2^4
[1] 4
[1] 8
[1] 16

3 * 2^3 + 1
[1] 25

If you want a fractional power, you enclose this in parentheses e.g.

64^(1/2)
[1] 8

64^(-2)
[1] 0.0002441406

A square root is simply a power of 0.5 e.g. x^0.5 but there is a special command sqrt() to deal with this.

x = c(9, 16, 25, 36, 49, 59)
sqrt(x)
[1] 3.000000 4.000000 5.000000 6.000000 7.000000 7.681146

You can use the % symbol to compute modulo (%%) and integer division (%/%) like so:

16 %/% 3
[1] 5

16 %% 3
[1] 1

So, you have 16 ÷ 3 giving 5 and 1 remainder.

There are a bunch of commands associated with matrix math.

Multiply two matrices using the %*% operator.

## Make some matrices
(x = cbind(1,1:3,c(2,0,1)))
[,1] [,2] [,3]
[1,]    1    1    2
[2,]    1    2    0
[3,]    1    3    1

(y = c(1, 3, 2))
[1] 1 3 2

(y1 = matrix(1:3, nrow = 1))
[,1] [,2] [,3]
[1,]    1    2    3

(z = matrix(3:1, ncol = 1))
[,1]
[1,]    3
[2,]    2
[3,]    1

## Various multiplications
> x %*% y
[,1]
[1,]    8
[2,]    7
[3,]   12

x %*% y1 # Order can be important
Error in x %*% y1 : non-conformable arguments

y1 %*% x
[,1] [,2] [,3]
[1,]    6   14    5

x %*% z
[,1]
[1,]    7
[2,]    7
[3,]   10

z %*% x # Order is important
Error in z %*% x : non-conformable arguments

y %*% y # Matrix multiplication of two vectors
[,1]
[1,]   14

You can compute the cross product using the %*% operator and the t() command. Alternatively the crossprod() and tcrossprod() commands can do the job:

(x = cbind(1,1:3,c(2,0,1)))
[,1] [,2] [,3]
[1,]    1    1    2
[2,]    1    2    0
[3,]    1    3    1

(y = c(1, 3, 2))
[1] 1 3 2

(y1 = matrix(1:3, nrow = 1))
[,1] [,2] [,3]
[1,]    1    2    3

## Cross products
> crossprod(x, y) # Same as t(x) %*% y
[,1]
[1,]    6
[2,]   13
[3,]    4

crossprod(x, y1) # Gives error as y1 wrong “shape”
Error in crossprod(x, y1) : non-conformable arguments

tcrossprod(x, y1) # Same as x %*% t(y1)
[,1]
[1,]    9
[2,]    5
[3,]   10

There are various other commands associated with matrix math. They are not really operators (except %o%) as such but I’ll list them here:

Some operators are used to provide a logical result (i.e. TRUE or FALSE).

The & operator is used for the logical AND in an elementwise manner. If you double up the operator && you perform the operation on only the first element

The vertical bar | is used for the logical OR in an elementwise manner. If you double up the operator || you perform the operation on only the first element.

The ! operator is used for the logical NOT.

The command xor(x, y) acts as an exclusive OR operator.

The logical operators work in conjunction with other operators (comparisons) to produce results. So, look at the examples in the next section.

Comparison operators allow you to compare elements. These are often used in conjunction with the logical operators.

Here are some simple examples:

## Make some vectors
yy = c(2, 3, 6, 5, 3)
zz = c(4, 2, 4, 7, 4)

yy ; zz

[1] 2 3 6 5 3
[1] 4 2 4 7 4

yy > 4 # Elements greater than 4
[1] FALSE FALSE  TRUE  TRUE FALSE

zz != 4 # Elements not equal to 4
[1] FALSE  TRUE FALSE  TRUE FALSE

zz == 4 # Elements that are equal to 4
[1]  TRUE FALSE  TRUE FALSE  TRUE

yy > 3 & zz > 4 # Two conditions AND
[1] FALSE FALSE FALSE  TRUE FALSE

yy > 3 && zz > 4 # Test first element only
[1] FALSE

yy == 3 | zz == 4 # Two conditions OR
[1]  TRUE  TRUE  TRUE FALSE  TRUE

xor(yy > 3, zz > 4) # Exclusive OR
[1] FALSE FALSE  TRUE FALSE FALSE

The comparison and logical operators are used to obtain TRUE/FALSE results. However, they are not always the best choice for selection. There are times when you are looking for a single logical result but using regular operators either fails, or produces more than one. In these cases, the selection commands are helpful. They aren’t strictly mathematical operators but it is helpful to be aware of them. Additionally the isTRUE() command can “force” a single logical as a result.

Use the any() command to return a single TRUE result if any element meets the specified criteria.

Use the all() command to return a single TRUE result if all elements meet the specified criteria.

The identical() command compares two items and returns a TRUE if they are exactly equal. The all.equal() command is similar but with a bit more tolerance.

(yy = c(2, 3, 6, 5, 3)) # Make a vector
[1] 2 3 6 5 3

any(yy > 5) # Are any elements > 5?
[1] TRUE

all(yy < 5) # Are all elements < 5?
[1] FALSE

all(yy >= 2) # Are all elements >= 2?
[1] TRUE

## Some simple values
x1 = 0.5 – 0.3
x2 = 0.3 – 0.1

## Are results the same?
x1 == x2
[1] FALSE

## Set tolerance to 0 to show actual difference
all.equal(x1, x2, tolerance = 0)
[1] “Mean relative difference: 1.387779e-16”

## Use default tolerance
all.equal(x1, x2)
[1] TRUE

# Wrap command in isTRUE() for logical
isTRUE(all.equal(x1, x2))
[1] TRUE

isTRUE(all.equal(x1, x2, tolerance = 0))
[1] FALSE

## Character vectors
pp = c(“a”, “f”, “h”, “q”, “r”)
qq = c(“d”, “e”, “x”, “c”, “s”)
rr = pp

# Test for equality
all.equal(pp, qq)
[1] “5 string mismatches”

identical(x1, x2)
[1] FALSE

identical(pp, qq)
[1] FALSE

identical(pp, rr)
[1] TRUE

Note that you can use identical(TRUE, x) in lieu of isTRUE(x), where x is the condition to test.

You can use the which() command to obtain an “index” instead of a logical result. The command works in conjunction with the comparison and logical operators but returns a result that indicates which elements match your criteria.

yy = c(2, 3, 6, 5, 3)
yy
[1] 2 3 6 5 3

which(yy > 3)
[1] 3 4

which(yy == 3)
[1] 2 5

Complex numbers are those with “imaginary” parts. You can make complex numbers using the complex() and as.complex() commands, whilst the is.complex() command provides a quick logical test to see if an object has the class “complex”. R has several commands that can deal with complex numbers.

Here are some simple examples:

## Make some complex numbers
z0 = complex(real = 1:8, imaginary = 8:1)
z1 = complex(real = 4, imaginary = 3)
z2 = complex(real = 4, imaginary = 3, argument = 2)
z3 = complex(real = 4, imaginary = 3, modulus = 4, argument = 2)

z0 ; z1 ; z2 ; z3
[1] 1+8i 2+7i 3+6i 4+5i 5+4i 6+3i 7+2i 8+1i
[1] 4+3i
[1] -0.4161468+0.9092974i
[1] -1.664587+3.63719i

## Get the real and imaginary parts of a complex object
Re(z0)
[1] 1 2 3 4 5 6 7 8

Im(z0)
[1] 8 7 6 5 4 3 2 1

## Get the Argument and Modulus
Arg(z1)
[1] 0.6435011

Mod(z1)
[1] 5

## Display the complex conjugate
Conj(z2)
[1] -0.4161468-0.9092974i

## Get the modulus and argument
Mod(z3)
[1] 4

Arg(z3)
[1] 2

Besides these special commands, the regular math operators work on complex numbers:

z0 + z1
[1]  5+11i  6+10i  7+ 9i  8+ 8i  9+ 7i 10+ 6i 11+ 5i 12+ 4i

z0 * z1
[1] -20+35i -13+34i  -6+33i   1+32i   8+31i  15+30i  22+29i  29+28i

z2 / z3
[1] 0.25+0i

There are various commands that deal generally with precision and rounding.

These are all fairly obvious; here are some examples:

## Make some values
yy = log(2^(2:6))
yy
[1] 1.386294 2.079442 2.772589 3.465736 4.158883

floor(yy)
[1] 1 2 2 3 4

ceiling(yy)
[1] 2 3 3 4 5

trunc(yy)
[1] 1 2 2 3 4

round(yy, digits = 3)
[1] 1.386 2.079 2.773 3.466 4.159

signif(yy, digits = 3)
[1] 1.39 2.08 2.77 3.47 4.16

## Include negative numbers
xx = -3:3
xx
[1] -3 -2 -1  0  1  2  3

sign(xx)
[1] -1 -1 -1  0  1  1  1

abs(xx)
[1] 3 2 1 0 1 2 3

These commands work on most numeric objects (e.g. data.frame, vector, matrix, table). If you have logical objects, you’ll return 1 for a TRUE and 0 for a FALSE.

You can enter numbers using an exponent to make it easier to deal with very large or very small values. The exponent is indicated by the letter e or E. You can use the – sign to indicate a negative exponent. The + sign can be omitted. You must not leave a space between the value and the exponent. You can only add an exponent to a numeric value and not to a named object.

1e3
[1] 1000

1E4
[1] 10000

1 e-2
Error: unexpected symbol in “1 e”

1e-2
[1] 0.01

Values are generally “printed” by R in regular format but sometimes they will appear in scientific format. This makes no difference to your calculations but sometimes you want the result to be displayed in scientific format and at other times not. There are two ways to achieve the result you want.

The simplest way to present your results objects in an appropriate format is to use the format() command. You simply set scientific = TRUE to prepare an object in that format (set FALSE to use regular format). The downside to this is that the object is prepared as a text result, which might be inconvenient.

The other way is to alter the options() and to set the scipen option. The default is 0. Negative values tend to produce scientific notation and positive values are less likely to do so.

## Make some values
yy = c(1, 10, 100, 1000, 10000, 100000)
zz = c(1, 12, 123, 1234, 12345, 123456)

yy ; zz
[1] 1e+00 1e+01 1e+02 1e+03 1e+04 1e+05
[1]      1     12    123   1234  12345 123456

## Use format() to force scientific or foxed format
format(yy, scientific = FALSE)
[1] ”     1″ ”    10″ ”   100″ ”  1000″ ” 10000″ “100000”

format(zz, scientific = TRUE, digits = 3)
[1] “1.00e+00” “1.20e+01” “1.23e+02” “1.23e+03” “1.23e+04” “1.23e+05”

## Check the scipen option
options(“scipen”)
$scipen
[1] 0

## Set scipen
options(scipen = 1)
> yy
[1]      1     10    100   1000  10000 100000

options(scipen = -6)
zz
[1] 1.00000e+00 1.20000e+01 1.23000e+02 1.23400e+03 1.23450e+04 1.23456e+05

print(zz, digits = 3)
[1] 1.00e+00 1.20e+01 1.23e+02 1.23e+03 1.23e+04 1.23e+05

options(scipen = 0) # Reset scipen

You may need to tweak the values of scipen but in general the number of digits in the result is your guideline.

The largest and smallest items can be extracted using max() and min() commands respectively. These commands produce a single value as the result.

The range() command produces two values, the smallest and largest, in that order.

## Set random number generator
set.seed(99)

## Make some values
xx = runif(n = 10, max = 100, min = -100)

max(xx)
[1] 98.50176

min(xx)
[1] -77.24366

range(xx)
[1] -77.24366  98.50176

range(xx)[1] # Just the min value
[1] -77.24366

range(xx)[2:1] # Display max then min
[1]  98.50176 -77.24366

If you want the 2nd largest, or the 3rd smallest (for example) then you need to use the order() command to get an “index”. Set the sort order to decreasing = FALSE (the default) to get the smallest values, set decreasing = TRUE to get the largest values.

xx
[1]  16.942370 -77.243665  36.852949  98.501755   6.998717  93.322813  34.285512
[8] -41.084458 -28.327403 -64.937049

order(xx) # Index in ascending order
[1]  2 10  8  9  5  1  7  3  6  4

xx[order(xx)[1]] # 1st smallest (min)
[1] -77.24366

xx[order(xx)[2]] # 2nd smallest
[1] -64.93705

xx[order(xx, decreasing = TRUE)[1]] # 1st largest (max)
[1] 98.50176

xx[order(xx, decreasing = TRUE)[2]] # 2nd largest
[1] 93.32281

Logarithms and their reverse (anti-logs?) are dealt with using the log() and exp() commands respectively. The default base is the natural log (e) but you can specify the base explicitly. There are also several convenience commands:

Using the commands is fairly simple.

log(1:4) # Natural log
[1] 0.0000000 0.6931472 1.0986123 1.3862944

log(1:4, base = 3) # Log base 3
[1] 0.0000000 0.6309298 1.0000000 1.2618595

log10(1:4) # Log base 10
[1] 0.0000000 0.3010300 0.4771213 0.6020600

log2(1:4) # Log base 2
[1] 0.000000 1.000000 1.584963 2.000000

log(0:3) # Regular log gives infinity for 0
[1]      -Inf 0.0000000 0.6931472 1.0986123

log1p(0:3) # Add 1 to values then log
[1] 0.0000000 0.6931472 1.0986123 1.3862944

10^0.6 # The antilog (base 10) of 0.6
[1] 3.981072

3^0.63 # The antilog (base 3) of 0.63
[1] 1.997958

exp(1.098) # The natural antilog of 1.098
[1] 2.998164

expm1(1.098) # The natural antilog of 1.098 then minus 1
[1] 1.998164

R has a suite of commands that carry out trigonometric functions.

The commands work out the basic functions and also hyperbolic equivalents. Angles are in radians (a right angle is pi/2 radians).

Here are some simple examples using the cosine:

cos(45) # Angle in radians
[1] 0.525322

cos(45 * pi/180) # Convert 45 radians to degrees
[1] 0.7071068

acos(1/2) * 180/pi # To get result in degrees
[1] 60

acos(sqrt(3)/2) * 180/pi # To get result in degrees
[1] 30

cosh(0.5) # Hyperbolic function
[1] 1.127626

There are various commands associated with lists of values (that is list in a general sense, not an R list object).

The sum() command returns the sum of all the numbers specified. This works for most R objects, including data.frame, matrix and vectors. Logical values are treated as 1 (TRUE) or 0 (FALSE). NA items are treated as 0. You can “ignore” NA items using na.rm = TRUE as a parameter in the command.

The prod() command returns the product of all the numbers specified, that is each value multiplied by the “next”. This works for most R objects, including data.frame, matrix and vectors (items are taken columnwise for data.frame objects). Logical values are treated as 1 (TRUE) or 0 (FALSE). NA items are treated as 0. You can “ignore” NA items using na.rm = TRUE as a parameter in the command.

v = 1:9
m = matrix(1:9, ncol = 3)
d = data.frame(a = 1:3, b = 4:6, c = 7:9)
v ; m ; d
[1] 1 2 3 4 5 6 7 8 9

[,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

a b c
1 1 4 7
2 2 5 8
3 3 6 9

## sum for vector, matrix and data.frame
sum(v)
[1] 45

sum(m)
[1] 45

sum(d) # Reads data columnwise
[1] 45

## product for vector, matrix and data.frame
prod(v)
[1] 362880

prod(m)
[1] 362880

prod(d) # Reads data columnwise
[1] 362880

## Make a locical vector
z = c(TRUE, TRUE, FALSE, TRUE)
z
[1]  TRUE  TRUE FALSE  TRUE

## Results for logicals
sum(z)
[1] 3

prod(z)
[1] 0

The factorial() command is similar to prod(). With prod() you specify prod(x:y) as a sequence, whilst in factorial() you specify factorial(y). If you provide more than one value, you end up with multiple results:

factorial(3) # i.e. 3 * 2 * 1
[1] 6

factorial(5) # i.e. 5 * 4 * 3 * 2 * 1
[1] 120

factorial(v)
[1]      1      2      6     24    120    720   5040  40320 362880

factorial(m)
[,1] [,2]   [,3]
[1,]    1   24   5040
[2,]    2  120  40320
[3,]    6  720 362880

You can also use the gamma() command, which equates to factorial(x-1). Essentially prod(x:y) = gamma(y+1) = factorial(y).

There are several cumulative functions built-in to R. These determine sum, product, maximum and minimum.

The commands operate on numeric objects, usually vector or matrix objects. The commands work on data.frame objects but compute results per column. The commands do not work directly on lists (but you can use the lapply() command).

v = 1:9
m = matrix(1:9, ncol = 3)
d = data.frame(a = 1:3, b = 4:6, c = 7:9)
v ; m ; d
[1] 1 2 3 4 5 6 7 8 9

[,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

a b c
1 1 4 7
2 2 5 8
3 3 6 9

cumsum(v)
[1]  1  3  6 10 15 21 28 36 45

cumprod(m)
[1]      1      2      6     24    120    720   5040  40320 362880

cummax(d) # For data.frame calculations are carried out column by column
a b c
1 1 4 7
2 2 5 8
3 3 6 9

It is possible to make custom functions that calculate other cumulative results, but that is another story.

There are many other mathematical functions in R. This has been a brief overview of some of the “simpler” arithmetic (although the foray into logic may not count as math).