Convert Data Frame to Matrix in R (With Examples)

Converting data structures is a common operation in statistical programming. In R, the transformation from a data frame to a matrix is frequently required, especially when preparing data for specific mathematical operations or statistical modeling that requires homogeneous data types. While both structures hold two-dimensional data, a data frame is designed to handle heterogeneous columns (mixing numeric, character, or logical data types), whereas a matrix strictly enforces homogeneity—meaning all elements must be of the same type.

Fortunately, the R environment provides robust functions within its base R package to handle this conversion seamlessly, eliminating the need for external libraries. The appropriate function depends entirely on the data types present in your original data frame.

Overview of Base R Conversion Methods

To convert a data frame into a matrix in R, you can utilize one of two primary methods, each tailored for different scenarios based on the composition of the data frame’s columns. Both methods leverage functions built into base R, ensuring that no additional package installation is necessary.

The selection criteria hinge on whether your data frame contains only numeric columns or if it includes character or factor columns.

• Method 1: Using as.matrix(): This function is ideal when the data frame consists exclusively of numeric or logical data. It performs a direct conversion while preserving the data’s original mode.
• Method 2: Using data.matrix(): This function is specifically designed to handle data frames containing mixed data types, such as character strings or factors. It performs automatic type coercion, converting all variables into a numeric mode before creating the matrix.

The following examples demonstrate how to apply these functions effectively in practice, illustrating the necessary steps and the resulting output structure.

Method 1: Converting a Purely Numeric Data Frame using as.matrix()

When working with quantitative data, your data frame often contains only numeric columns. In this straightforward scenario, the as.matrix() function is the most direct and efficient tool for conversion. This function treats the data frame as a collection of vectors and binds them together as columns, creating a homogeneous matrix structure.

Consider a scenario where we have aggregated sports statistics, which are all inherently numeric. We first create the example data frame:

#create data frame
df <- data.frame(points=c(99, 90, 86, 88, 95),
                 assists=c(33, 28, 31, 39, 34),
                 rebounds=c(30, 28, 24, 24, 28))

#view data frame
df

  points assists rebounds
1     99      33       30
2     90      28       28
3     86      31       24
4     88      39       24
5     95      34       28

To convert this structure into a matrix, we simply pass the data frame object (df) to the as.matrix() function. Since all columns are already numeric, R performs the conversion without altering the underlying data values.

#convert data frame to matrix
mat <- as.matrix(df)

#view matrix
mat

     points assists rebounds
[1,]     99      33       30
[2,]     90      28       28
[3,]     86      31       24
[4,]     88      39       24
[5,]     95      34       28

#view class of mat
class(mat)

[1] "matrix" "array"

Inspecting the output confirms two crucial points: first, the structure retains the column names from the data frame; second, the class() function verifies that the new object, mat, is now recognized by R as both a matrix and an array. This method is straightforward and highly recommended for data that is already numeric.

Method 2: Handling Mixed Data Types with data.matrix()

When your data frame contains a mix of data types—specifically, if it includes character columns or factors alongside numeric data—using as.matrix() would result in a character matrix where all numeric values are converted to strings. Since matrices require homogeneity, this outcome is usually undesirable for mathematical processing. Instead, the data.matrix() function is the specialized tool designed to handle this scenario by forcing all data into a numeric mode.

Let’s introduce a character column, team, into our previous data set. This column represents a categorical variable, making the data frame heterogeneous:

#create data frame
df <- data.frame(team=c('A', 'A', 'B', 'B', 'C'),
                 points=c(99, 90, 86, 88, 95),
                 assists=c(33, 28, 31, 39, 34))

#view data frame
df

  team points assists
1    A     99      33
2    A     90      28
3    B     86      31
4    B     88      39
5    C     95      34

Applying the data.matrix() function causes R to analyze each column. The existing numeric columns (points and assists) remain unchanged. However, the character column (team) undergoes a critical transformation: R converts the categorical data into internal numeric codes, allowing the resulting structure to be a purely numeric matrix.

#convert data frame to matrix
mat <- data.matrix(df)

#view matrix
mat

     team points assists
[1,]    1     99      33
[2,]    1     90      28
[3,]    2     86      31
[4,]    2     88      39
[5,]    3     95      34

#view class of mat
class(mat)

[1] "matrix" "array"

Upon viewing the resulting matrix, we observe that the team column now contains the values 1, 2, and 3 instead of ‘A’, ‘B’, and ‘C’. This confirms that data.matrix() successfully performed the necessary coercion to meet the homogeneity requirement of the matrix structure.

Understanding Factor and Character Coercion

The behavior observed in Method 2—where character or factor variables are automatically mapped to integers—is a key feature of the data.matrix() function. When R encounters non-numeric data that must be converted to a matrix, it utilizes the internal representation of categorical variables.

If the original column was a Factor, R simply extracts the internal numeric codes associated with each level. If the column was a character vector, R first converts it to a factor, determines the levels, and then extracts those numeric codes. These codes are assigned sequentially based on the order of unique factor levels.

We can confirm this mechanism by consulting the official R documentation for the function:

?data.matrix

The description provided by the help file is highly informative:

Description:
     Return the matrix obtained by converting all the variables in a
     data frame to numeric mode and then binding them together as the
     columns of a matrix.  Factors and ordered factors are replaced by
     their internal codes.

This explains precisely why the unique team identifiers (‘A’, ‘B’, ‘C’) were converted to the values 1, 2, and 3, respectively, in the resulting matrix. This automatic conversion is highly convenient but requires the user to remember that the resulting matrix contains numeric representations of categorical data, which may impact subsequent mathematical analyses if not handled correctly.

Summary of Key Differences

Choosing between as.matrix() and data.matrix() depends entirely on the heterogeneity of your starting data frame. Using the wrong function can lead to undesired data type conversions, potentially corrupting your data structure for later analysis.

The following list summarizes the key behavioral differences to guide your selection:

• as.matrix(): If the data frame is purely numeric, it returns a numeric matrix. If the data frame contains *any* character or non-numeric elements, it defaults to coercing the *entire* matrix to a character matrix, treating the numbers as strings.
• data.matrix(): This function always guarantees a numeric matrix. It handles non-numeric columns (characters or factors) by converting them into their underlying numeric codes, facilitating immediate use in numerical algorithms.

For modeling purposes where all inputs must be strictly numeric, data.matrix() offers a safer way to ensure numerical homogeneity, provided the integer coding of categorical variables is acceptable for the intended purpose.

Additional Resources for Data Structure Operations

Mastering the manipulation of R’s core data structures—data frames, vectors, lists, and matrices—is essential for efficient data science workflows. Expanding knowledge beyond simple conversion allows for more complex data reshaping and management.

The following resources explain how to perform other common and advanced operations in R: