Polymorphism in R Programming

R language implements parametric polymorphism, which means that methods in R refer to functions, not classes. Parametric polymorphism primarily lets us define a generic method or function for types of objects we haven’t yet defined and may never do. This means that one can use the same name for several functions with different sets of arguments and from various classes.

Generic Functions

Polymorphism in R can be obtained by the generics. It allows certain names to be treated as methods and they act as dispatchers. Dispatchers help R decide which function to use depending on the type of input.

Let’s understand with the help of plot function and summary function. In R programming , the plot() and summary() functions return different results depending on the objects being passed to them and that’s why they are generic functions that implement polymorphism.

1. plot() in R

plot() is one of the generic functions that implement polymorphism in R. It produces a different graph depending upon its input (vector, factor, data frame, etc). Let’s see the code for the plot function.

plot

Output:

function (x, y, …)
UseMethod(“plot”)

We can see that , the body of the plot function contains only one expression and that is UseMethod(“plot”). Let’s see the definition of UseMethod using help() function.

help(UseMethod)

Output:

From the above output, we can see that UseMethod takes two parameters generic and object.

• The generic is the string name, which is the name of the function (plot in this case).
• This is an object whose class will determine the method that will be “dispatched”. This means the object’s class decides which version of the function will be used.

The UseMethod then searches for the suitable plot function that is needed to be called by creating a string of the type plot.object. We can also see all the available methods for the plot function.

methods(plot)

Output:

Let’s see how plot() function taking arguments and displaying different outputs.

Input as a numeric vector

In this example let’s take a single numeric vector inside plot() function as a parameter.

# X Window System Graphics (X11)
X11(width = 15, height = 13)

x <- 3 * runif(40) + (1:30)

par(mar = c(20, 20, 1, 1))
plot(x, type = 'l', col = '#343deb')

z <- locator(1)

 Output:

Inputs as two numeric vectors

We need to pass two vector parameters and it produces a scatter plot accordingly.

X11(width = 5, height = 3)

x <- runif(20)
y <- runif(20) * x
par(mar = c(2, 2, 0.3, 0.3))

plot(x, y, type = 'p', pch = 16, col = '#ab1ab0')

z <- locator(1)

 Output:

Input as factor

If we passed factor as arguments then we get a bar chart pattern. 

X11(width = 5, height = 8)

f <- factor(c('apple', 'orange', 'apple', 'pear', 'orange',
              'apple', 'apple', 'orange'))

par(mar = c(2, 2, 0.6, 0.6))

plot(f, col = '#8f4c91')
z <- locator(1)

 Output:

Input as data frame

The Plot function takes the data frame as an argument and each variable of the data frame is plotted against each other.

X11(width = 6, height = 6)

set.seed(280870)
x <- c(4, 3, 1, 2, 2, 4, 6, 4, 5, 5, 
       4, 4, 5, 4, 4, 8, 4, 1, 2, 7)
y <- x * rnorm(20, 1, 0.3)
z <- x * y

df <- data.frame(x, y, z)
par(mar = c(0.1, 0.1, 0.1, 0.1))

plot(df, col = '#a832a6', pch = 16, cex = 1.5)
z <- locator(1)

 Output:

2. summary() in R

summary() is also a generic function that implements polymorphism in R. It is used to produce summaries of the results of various model fitting functions.

Example 1:

colors <- c("violet", "indigo", "blue", "green",
            "yellow", "orange", "red")
summary(colors)

 Output:

Length Class Mode
7 character character

Example 2:

Let us check for summarized results for state.region. In R it usually displays what regions are available under “Northeast”, “South”, “North Central”, and “West”. Using summary() function, either one can pass state.region as 1st parameter and as a second step, (optionally) pass “maxsum” argument. “maxsum” indicates how many levels should be shown for factors in output.

state.region
summary(state.region) 
summary(state.region, maxsum = 3) 

Output:

> state.region
[1] South West West South West West
[7] Northeast South South South West West
[13] North Central North Central North Central North Central South South
[19] Northeast South Northeast North Central North Central South
[25] North Central West North Central West Northeast Northeast
[31] West Northeast South North Central North Central South
[37] West Northeast Northeast South North Central South
[43] South West Northeast South West South
[49] North Central West
Levels: Northeast South North Central West

> summary(state.region)
Northeast South North Central West
9 16 12 13

> summary(state.region, maxsum = 3)
South West (Other)
16 13 21

Example 3:

Let’s have a look on how the summary() function works if the data set is very large .

x <- stats::rnorm(10)
x

c <- cut(x, breaks = -3:3)
c

summary(c)

 Output:

> x
[1] 0.66647846 -0.29140286 -0.29596477 -0.23432541 -0.02144178 1.56640107 0.64575227
[8] -0.23759734 0.73304657 -0.04201218

> c
[1] (0,1] (-1,0] (-1,0] (-1,0] (-1,0] (1,2] (0,1] (-1,0] (0,1] (-1,0]
Levels: (-3,-2] (-2,-1] (-1,0] (0,1] (1,2] (2,3]

> summary(c)
(-3,-2] (-2,-1] (-1,0] (0,1] (1,2] (2,3]
0 0 6 3 1 0

Till now, we have described the plot() and summary() function which is a polymorphic function. By means of different inputs, plot() function behavior is changing and producing outputs. Here we can see the polymorphism concept. Similarly, in summary(), function, by means of varying parameters, the same method is applicable to provide different statistical outputs. Now let’s create our own generic methods.

Creating Generic Method

Let’s create a Bank class and define a custom display() method that uses the print() function to show the contents of the class in our custom format.
For doing this we first have to create a generic display() function that will use the UseMethod function.

display <- function(obj){
    UseMethod("print")
}

After creating the generic display function let’s create the display function for our class bank.

print.bank<-function(obj)
{
    cat("Name is ", obj$name, "\n")
    cat(obj$account_no, " is the Acc no of the holder\n ")
    cat(obj$saving, " is the amount of saving in the account \n ")
    cat(obj$withdrawn, " is the withdrawn amount\n")
}

Now, let’s see the output given by this function

x <- list(name ="Arjun", account_no = 1234,
        saving = 1500, withdrawn = 234)
class(x)<-"bank"

display <- function(obj){
    UseMethod("print")
}

print.bank<-function(obj)
{
    cat("Name is ", obj$name, "\n")
    cat(obj$account_no, " is the Acc no of the holder\n ")
    cat(obj$saving, " is the amount of saving in the account \n ")
    cat(obj$withdrawn, " is the withdrawn amount\n")
}

display(x)

Output:

Name is Arjun
1234 is the Acc no of the holder
1500 is the amount of saving in the account
234 is the withdrawn amount

In this article, we explored how R supports polymorphism through generic functions like plot() and summary(), and demonstrated how to create custom generic methods using UseMethod() by building a simple Bank class.

priyarajtt

Follow

Improve

Article Tags :

• Python
• R Language
• R-OOPs

Practice Tags :

• python