Plot Multiple Lines (data series) in One Chart in R

This comprehensive tutorial explains the essential techniques required to visualize data series by plotting multiple lines simultaneously on a single chart using the R programming language. Visualizing complex, multivariate data is a foundational skill in data analysis, and line plots are indispensable for illustrating trends, comparisons, and changes over time or across categories. We will explore two primary methodologies for achieving this visualization goal: utilizing the core functionality provided by Base R and harnessing the powerful grammar of graphics provided by the ggplot2 package.

When dealing with datasets containing several variables that require comparative visualization, plotting all relevant lines onto one axis provides immediate context and clarity. For instance, comparing the performance of three different stocks over a year, or tracking the temperature fluctuations recorded by multiple sensors, mandates a multi-line approach. The choice between using Base R and ggplot2 often depends on the user’s familiarity, the complexity of the required plot customization, and whether they operate within the larger R Tidyverse ecosystem.

Choosing Your Tool: Base R vs. ggplot2

Base R: Efficiency and Quick Visualization

Base R offers highly efficient, built-in functions for generating visualizations without needing to install external libraries. This approach is often preferred for rapid prototyping, quick exploratory data analysis, or scenarios where minimal customization is required. The primary methods within Base R for plotting multiple lines include the specialized matplot() function—ideal for matrix-based data—and the sequential pairing of plot(), points(), and lines() for fine-grained control over individual data series. While extremely fast, customizing the appearance (such as themes, colors, and aesthetics) in Base R often requires more complex code and parameter adjustments compared to ggplot2.

Understanding the core difference in philosophy is crucial. Base R functions tend to modify the existing plot environment incrementally. When you use plot(), it initializes the canvas; subsequent calls to functions like lines() or points() add elements onto that existing canvas. This imperative style of coding gives the user direct control over every graphical element as it is added. We will examine two distinct examples demonstrating how to leverage these native functions to display multiple lines effectively.

The major advantage of relying on built-in Base R functionality is portability and minimal dependencies. If you are working in an environment where installing new packages is restricted, or if you need the absolute fastest plotting speed for very large datasets, the native functions are often the ideal solution. However, managing legends, colors, and specific aesthetic mappings can become cumbersome as the complexity of the plot increases beyond basic requirements.

Method 1: Utilizing Base R Functions

Base R Technique A: The Efficiency of matplot()

The matplot() function is specifically designed to plot the columns of a matrix or a data frame against the index or against another specified column. It is the most straightforward method available in Base R when your data is structured such that each column represents a separate data series that shares a common x-axis (typically the row index). This function automatically handles iterating through the columns and assigning default colors and line types, minimizing the necessary lines of code required for visualization.

In the following demonstration, we create a synthetic dataset structured as a matrix. This matrix contains 10 rows and 3 columns, with values randomly sampled from a uniform distribution between 1 and 10. We then use matplot() with the type = "b" argument, instructing R to plot both points (p) and connecting lines (l). The color argument col = 1:3 ensures that each of the three columns (data series) is assigned a distinct default color for easy differentiation. Finally, a legend is added to map the colors back to the corresponding series indices.

This approach is highly scalable; if your matrix had 50 columns, matplot() would effortlessly plot all 50 lines simultaneously, automatically cycling through the available default aesthetics. It is the go-to function for analyzing time series data stored in a wide format where columns represent different variables observed at sequential time points (rows).

Example 1: Using Matplot

If you have a dataset that is stored in a matrix format, one simple and powerful way to plot multiple lines in one chart is by using matplot():

#Create a fake dataset with 3 columns (ncol=3) composed of randomly generated
#numbers from a uniform distribution with minimum = 1 and maximum = 10
data <- matrix(runif(30,1,10), ncol=3)
data
        [,1]     [,2]     [,3]
#[1,] 5.371653 3.490919 3.953603
#[2,] 9.551883 2.681054 9.506765
#[3,] 3.525686 1.027758 8.059011
#[4,] 9.923080 1.337935 1.112361
#[5,] 7.273972 7.627546 1.174340
#[6,] 8.859109 3.778144 9.384526
#[7,] 9.614542 3.866029 7.301729
#[8,] 9.288085 5.804041 8.347907
#[9,] 1.696849 4.650687 7.220209
#[10,] 5.820941 4.799682 5.243663

#plot the three columns of the dataset as three lines and add a legend in
#the top right corner of the chart
matplot(data, type = "b",pch=1,col = 1:3)
legend("topright", legend = 1:3, col=1:3, pch=1)

This code successfully generates the following chart, where each of the three columns from the matrix is represented by a distinct line:

Base R Technique B: Granular Control with points() and lines()

For situations requiring maximum control over the aesthetics, specific axis scaling, or when the data series do not originate from a single matrix object, the sequential plotting method using plot(), points(), and lines() is more appropriate. This method starts by plotting the first series using plot(), which sets the initial axes boundaries and creates the canvas. Crucially, subsequent series must be added using points() to draw the markers and lines() to connect those markers, ensuring they are layered onto the existing graph rather than overwriting it.

This step-by-step approach allows the analyst to individually define characteristics like color, line type (lty), and symbol (pch) for every single line added. For example, one series might be displayed with a solid line and circles, while another uses a dashed line and asterisks, providing a rich visual distinction. This method is particularly useful when the scales of the different variables are vastly different, although careful consideration must be given to ensuring the initial plot() call creates axes large enough to encompass all subsequent data points.

The example below demonstrates defining three separate vectors (y1, y2, y3) along with a common x-axis vector (x). We initialize the plot using plot(x, y1, ...). Notice the type="o" argument used here, which plots both points and lines simultaneously for the initial series. The subsequent series (y2 and y3) are then added using pairs of points() and lines() calls, allowing us to explicitly define the aesthetics for each segment of the plot.

Example 2: Using Points & Lines

Another powerful way to plot multiple lines in Base R is to plot them one by one, using the built-in R functions points() and lines(). This technique provides granular control over the appearance of each individual data series. The code below demonstrates this iterative approach:

#generate an x-axis along with three data series
x  <- c(1,2,3,4,5,6)
y1 <- c(2,4,7,9,12,19)
y2 <- c(1,5,9,8,9,13)
y3 <- c(3,6,12,14,17,15)

#plot the first data series using plot()
plot(x, y1, type="o", col="blue", pch="o", ylab="y", lty=1)

#add second data series to the same chart using points() and lines()
points(x, y2, col="red", pch="*")
lines(x, y2, col="red",lty=2)

#add third data series to the same chart using points() and lines()
points(x, y3, col="dark red",pch="+")
lines(x, y3, col="dark red", lty=3)

#add a legend in top left corner of chart at (x, y) coordinates = (1, 19)
legend(1,19,legend=c("y1","y2","y3"), col=c("blue","red","black"),
                                   pch=c("o","*","+"),lty=c(1,2,3), ncol=1)

This sequential method generates the following highly customized chart, with distinct line types and symbols for each series:

Method 2: Leveraging the Power of ggplot2

The Grammar of Graphics Approach

The ggplot2 package, part of the R Tidyverse, offers a fundamentally different and often more intuitive approach to visualization based on the “Grammar of Graphics.” Instead of adding elements iteratively (as in Base R), ggplot2 requires data to be in a “long” or “tidy” format, where each observation has its own row and variables are mapped to aesthetic elements like x, y, color, or shape. This structure simplifies the process of plotting multiple data series significantly, as the mapping logic handles the grouping and coloring automatically.

To plot multiple lines using ggplot2, the key is to map the grouping variable (which defines the different series) to an aesthetic property, such as colour, within the aes() function inside geom_line(). This tells the package to draw a separate line for every unique value found in that grouping variable, simultaneously assigning a unique color or line type to each group. This automation dramatically reduces the risk of manual errors and improves code readability, making it the preferred method for complex, publication-quality graphics.

The following example demonstrates the mandatory steps: first, ensuring the data is in the correct long format (using data.frame where ‘variable’ defines the series), and second, passing this data to the ggplot() function. The initial ggplot(data = data, aes(x=x, y=value)) defines the general axes. The magic happens in the layer addition: geom_line(aes(colour=variable)) instructs ggplot2 to map the ‘variable’ column to the line color aesthetic, thereby plotting three distinct lines based on the three unique ‘series’ values. Furthermore, ggplot2 automatically generates a professional and comprehensive legend.

Example 3: Plotting with ggplot2

Here is an example demonstrating the power and simplicity of plotting multiple lines in one chart using the ggplot2 package. Note the requirement for the data to be in a tidy format (long format) for effective aesthetic mapping.

#install (if not already installed) and load ggplot2 package
if(!require(ggplot2)){install.packages('ggplot2')}

#generate fake dataset with three columns 'x', 'value', and 'variable'
data <- data.frame(x=rep(1:5, 3),
                   value=sample(1:100, 15), 
                   variable=rep(paste0('series', 1:3), each=5))

#view dataset
head(data)
  x value variable
1 1 93    series1
2 2 64    series1
3 3 36    series1
4 4 17    series1
5 5 95    series1
6 1 80    series2

#plot all three series on the same chart using geom_line()
ggplot(data = data, aes(x=x, y=value)) + geom_line(aes(colour=variable))

This generates the following clean and aesthetically pleasing chart, automatically handling the grouping and legend generation:

Additional Resources for R Plotting

Mastering multi-line plotting is just the first step in creating advanced visualizations in R. Whether you choose the efficiency of Base R or the structured approach of ggplot2, continuous exploration of plotting parameters and packages will enhance your data storytelling capabilities. For those focused on the Tidyverse, ggplot2 offers countless extensions and layers for creating everything from detailed scatter plots to complex geographical maps.

The following tutorials explain how to perform other common plotting operations and customizations within the R visualization ecosystem, providing context on manipulating titles, axes, and color palettes:

• How to add custom labels and titles to your visualizations.
• Techniques for using custom color palettes for improved accessibility.
• Generating interactive plots using packages like Plotly or Shiny.

By understanding the differences between the imperative approach of Base R (using functions like matplot() and lines()) and the declarative approach of ggplot2 (relying on aesthetic mappings), analysts can choose the most appropriate tool for any given data visualization challenge involving multiple data series.