r‑statistics.co by Selva Prabhakaran
About

R Error: 'non-numeric argument to binary operator', Find the Hidden Character

Error in x * y : non-numeric argument to binary operator means R was asked to do arithmetic on something that isn't a number. The fastest way to find the culprit is to ask class() what each operand actually is, once you know that, the fix is usually a single conversion function.

What does "non-numeric argument to binary operator" mean in R?

R throws this error the moment an arithmetic operator, +, -, *, /, ^, %%, sees an operand that isn't numeric. The value may print exactly like a number and still be a character string, a factor, or a date under the hood. The one-line diagnosis is class(): once you know what R thinks each operand is, the fix is usually a single conversion function.

Let's reproduce the error on purpose, then solve it in three lines.

RReproduce the non-numeric error
# A "price" that looks numeric but isn't price <- "19.99" qty <- 3 # This line would throw: # Error in price * qty : non-numeric argument to binary operator # Uncomment to see it: # price * qty # The diagnosis: ask R what each operand actually is class(price) #> [1] "character" class(qty) #> [1] "numeric" # The fix: convert price, then multiply total <- as.numeric(price) * qty total #> [1] 59.97

  

  





The string "19.99" and the number 19.99 print identically, but class() exposes the difference. Once you know which operand is the character, as.numeric() patches it in one call. The rest of this guide is about recognising the same mismatch when it's less obvious, buried inside data frames, hidden in whitespace, or wearing a factor disguise.



Key Insight
class() answers 90% of these errors in one line. Before you change any code, run class() on every operand of the failing expression. The error almost always goes away once you know which side is not numeric.





Try it: You have ex_price <- "42" and ex_qty <- 2. Write one line that computes the numeric total and stores it in ex_total.



  

    
RExercise: coerce price and multiply

    
# Try it: compute the total as a number
ex_price <- "42"
ex_qty <- 2

# your code here

# Check:
# ex_total should be 84 (numeric), not an error

    

      
      
    

    

  

  





Click to reveal solution



  

    
RCoerce-and-multiply solution

    
ex_total <- as.numeric(ex_price) * ex_qty
ex_total
#> [1] 84

    

      
      
    

    

  

  





Explanation: as.numeric() converts the character "42" to the number 42, and R can then multiply it by ex_qty.








How do you find the guilty column inside a data frame?



When the error comes from a data frame expression like df$revenue * df$qty, the trick is to scan every column at once. R gives you three escalating tools: str() for a full dump, sapply(df, class) for a one-line class vector, and sapply(df, is.numeric) for a straight yes/no answer.



Let's build a tiny shop data frame with one obvious character column hiding among numeric ones, then find it three different ways.




  

    
RFind guilty columns with sapply

    
shop <- data.frame(
  item     = c("Widget", "Gadget", "Doohickey"),
  price    = c("12.50", "8.00", "15.75"),   # LOOKS numeric, is character
  quantity = c(3, 5, 2),
  in_stock = c(TRUE, TRUE, FALSE)
)

# 1. Full structural dump
str(shop)
#> 'data.frame': 3 obs. of  4 variables:
#>  $ item    : chr  "Widget" "Gadget" "Doohickey"
#>  $ price   : chr  "12.50" "8.00" "15.75"
#>  $ quantity: num  3 5 2
#>  $ in_stock: logi  TRUE TRUE FALSE

# 2. One-line class vector
sapply(shop, class)
#>      item     price  quantity  in_stock
#> "character" "character" "numeric" "logical"

# 3. Straight yes/no filter, the one-line culprit finder
names(shop)[!sapply(shop, is.numeric)]
#> [1] "item"     "price"    "in_stock"

    

      
      
    

    

  

  





str() is great for eyeballing, but sapply(shop, is.numeric) is what you actually want in a script, it returns a named logical vector you can feed straight into column selection. Wrapping it with names(shop)[!...] prints exactly the columns that would break an arithmetic expression.



Tip
The one-line culprit finder is names(df)[!sapply(df, is.numeric)]. Keep it in your snippet library, it's the single fastest way to find every non-numeric column in a data frame, no matter how wide.





Try it: Using the data frame ex_df below, write one line that returns the names of every non-numeric column.



  

    
RExercise: list non-numeric column names

    
# Try it: list non-numeric column names
ex_df <- data.frame(
  id    = 1:3,
  score = c("88", "92", "79"),
  team  = c("A", "B", "A"),
  wins  = c(10, 8, 12)
)

# your code here

# Expected: c("score", "team")

    

      
      
    

    

  

  





Click to reveal solution



  

    
RNon-numeric columns solution

    
names(ex_df)[!sapply(ex_df, is.numeric)]
#> [1] "score" "team"

    

      
      
    

    

  

  





Explanation: sapply(ex_df, is.numeric) returns TRUE for id and wins, FALSE for score and team. Negating it with ! flips the selection to the non-numeric columns.








What hidden characters silently turn a numeric-looking column into text?



The hardest version of this bug is the column that looks numeric when you print() it but fails is.numeric(). A single stray character anywhere in the column forces the whole thing to character. The usual suspects are:



    


  1. Leading or trailing whitespace, " 19.99" from a poorly-trimmed CSV.
    2. 


  2. Currency symbols, "$19.99" or "€12.00".
    3. 


  3. Thousand separators, "1,200" from Excel exports.
    4. 


  4. Placeholder text, "N/A", "TBD", "-".
    5. 


  5. Stray units, "42kg", "15%".
    6. 


  6. Unicode minus, "−5" (U+2212) instead of ASCII -5.
    7. 





The cleanest fix is readr::parse_number(), which strips everything that isn't part of a number and converts in one call. It also keeps the bad rows as NA instead of crashing, which is what you usually want.




  

    
RClean messy strings with parsenumber

    
library(readr)

raw_prices <- c(" 19.99", "$20.00", "1,200.50", "N/A", "42kg")
class(raw_prices)
#> [1] "character"

# parse_number() extracts the numeric part from each string
cleaned <- parse_number(raw_prices, na = "N/A")
cleaned
#> [1]   19.99   20.00 1200.50      NA   42.00
class(cleaned)
#> [1] "numeric"

# Now arithmetic works
sum(cleaned, na.rm = TRUE)
#> [1] 1282.49

    

      
      
    

    

  

  





parse_number() handled whitespace, $, ,, and "42kg" without a single manual gsub. The one value it couldn't rescue, "N/A", became NA, which sum(..., na.rm = TRUE) ignores. That's a much safer outcome than a hard error mid-script.



Warning
One bad value drags the entire column to character. R data frames are column-typed, so if even a single cell in a 10,000-row column is "N/A" or "$", the whole column becomes character and every arithmetic operation on it fails. Clean on import, not after the error hits.





Try it: Clean the price vector ex_prices so its values become a numeric vector. Use any approach, gsub() + as.numeric() or parse_number().



  

    
RExercise: clean a dollar-prefixed vector

    
# Try it: clean a messy price vector
ex_prices <- c("$12.50", "$8.00", "$15.75")

# your code here

# Expected: c(12.50, 8.00, 15.75) as numeric

    

      
      
    

    

  

  





Click to reveal solution



  

    
RDollar-strip solution

    
# Option A, parse_number is the shortest:
parse_number(ex_prices)
#> [1] 12.50  8.00 15.75

# Option B, manual gsub + as.numeric:
as.numeric(gsub("\\$", "", ex_prices))
#> [1] 12.50  8.00 15.75

    

      
      
    

    

  

  





Explanation: parse_number() strips any non-numeric character automatically. The manual version uses gsub("\\$", "", ...) to remove the dollar signs, then as.numeric() to convert. Both produce the same numeric vector.








How do you fix the three common cause patterns?



Every instance of this error reduces to one of three root causes. Once you've diagnosed which pattern you're looking at, the fix is mechanical.







Pattern
What it looks like
Fix






A. Character that looks numeric
"19.99" from CSV or user input
as.numeric(x)




B. Factor used in arithmetic
factor(c(10, 20, 30))
as.numeric(as.character(x))




C. Messy strings with noise
"$1,200", "42kg", " 19.99 "
readr::parse_number(x)







Let's apply all three to one small data frame so you can see the patterns side-by-side.




  

    
RFix character factor and messy columns

    
mess <- data.frame(
  clean_char   = c("10", "20", "30"),                  # Pattern A
  factor_score = factor(c("85", "92", "78")),          # Pattern B
  messy_price  = c("$1,200", "$850", "$2,300")         # Pattern C
)

# Pattern A fix
mess$clean_char <- as.numeric(mess$clean_char)

# Pattern B fix, NEVER skip the as.character() step
mess$factor_score <- as.numeric(as.character(mess$factor_score))

# Pattern C fix
mess$messy_price <- parse_number(mess$messy_price)

sapply(mess, class)
#>   clean_char factor_score  messy_price
#>    "numeric"    "numeric"    "numeric"

# Arithmetic now works across every column
rowSums(mess)
#> [1] 1295  962 2408

    

      
      
    

    

  

  





All three columns are numeric after the fix, and rowSums(mess), which would have errored before, now returns one total per row. Pattern B is the one that trips people up most: calling as.numeric() directly on a factor returns the level indices, not the label values. The as.character() step rescues the original strings first.



Warning
Calling as.numeric() directly on a factor returns level indices, not labels. as.numeric(factor(c("10","20","30"))) returns 1 2 3, not 10 20 30. Always route factors through as.character() first: as.numeric(as.character(x)).





Try it: ex_scores is a factor of test scores. Convert it to numeric and compute the mean.



  

    
RExercise: factor scores to mean

    
# Try it: factor to numeric mean
ex_scores <- factor(c("88", "92", "79", "95", "84"))

# your code here

# Expected mean: 87.6

    

      
      
    

    

  

  





Click to reveal solution



  

    
RFactor-mean solution

    
mean(as.numeric(as.character(ex_scores)))
#> [1] 87.6

    

      
      
    

    

  

  





Explanation: as.character(ex_scores) recovers the label strings "88" "92" "79" "95" "84". as.numeric() then converts them to real numbers, and mean() averages them. Skipping as.character() would have averaged the level indices instead and produced the wrong answer.








Practice Exercises



Exercise 1: Clean an orders table and compute total cost



The orders data frame has two type problems: price is a character with dollar signs, and quantity is a factor. Compute total_cost = price * quantity for each row, then sum() them into a grand total called grand_total.




  

    
RExercise: fix orders grand total

    
# Capstone 1: fix the orders table and compute grand_total
orders <- data.frame(
  item     = c("Widget", "Gadget", "Doohickey"),
  price    = c("$12.50", "$8.00", "$15.75"),
  quantity = factor(c("3", "5", "2")),
  stringsAsFactors = FALSE
)

# Hint: fix price with parse_number(), fix quantity via as.character() -> as.numeric()

# your code here

# Expected grand_total: 109.00

    

      
      
    

    

  

  






Click to reveal solution



  

    
ROrders grand-total solution

    
orders$price    <- parse_number(orders$price)
orders$quantity <- as.numeric(as.character(orders$quantity))

orders$total_cost <- orders$price * orders$quantity
grand_total       <- sum(orders$total_cost)

print(orders)
#>        item price quantity total_cost
#> 1    Widget 12.50        3      37.50
#> 2    Gadget  8.00        5      40.00
#> 3 Doohickey 15.75        2      31.50
grand_total
#> [1] 109

    

      
      
    

    

  

  





Explanation: parse_number() strips the dollar signs from price in one call. quantity needs the as.character() detour because it's a factor. Once both columns are numeric, multiplication and sum() work.






Exercise 2: Auto-clean every non-numeric column in a survey



survey has three suspect columns (q1, q2, q3) that should all be numeric but look like they were typed by humans. Write a short pipeline that (a) finds the non-numeric columns, (b) cleans each with parse_number(), and (c) adds a row_total column. Don't hard-code column names, use sapply() so your code works on any survey.




  

    
RExercise: generic parse pipeline

    
# Capstone 2: detect + clean + total, all from a generic pipeline
survey <- data.frame(
  respondent = c("A", "B", "C"),
  q1 = c(" 4 ", "5", "3"),
  q2 = c("4.5", "N/A", "3"),
  q3 = c("5pts", "4pts", "2pts")
)

# Hint: identify non-numeric columns with sapply(survey, is.numeric),
# then lapply() parse_number() over the bad columns.

# your code here

# Expected: survey with q1/q2/q3 numeric, plus a row_total column

    

      
      
    

    

  

  






Click to reveal solution



  

    
RGeneric parse solution

    
bad_cols <- names(survey)[!sapply(survey, is.numeric) & names(survey) != "respondent"]

survey[bad_cols] <- lapply(survey[bad_cols], parse_number)

survey$row_total <- rowSums(survey[bad_cols], na.rm = TRUE)

print(survey)
#>   respondent q1  q2 q3 row_total
#> 1          A  4 4.5  5      13.5
#> 2          B  5  NA  4       9.0
#> 3          C  3 3.0  2       8.0

    

      
      
    

    

  

  





Explanation: sapply(survey, is.numeric) flags q1, q2, q3 as non-numeric, and we exclude respondent by name because it's supposed to stay character. lapply(..., parse_number) cleans them all in one pass. rowSums(..., na.rm = TRUE) tolerates the NA from the "N/A" cell so respondent B still gets a total.






Complete Example: Debug a Broken Revenue Report



Here's the kind of mess that shows up in real CSV exports. The revenue_df data frame should let us compute total revenue per region, but every numeric column is secretly a character, and one is a factor. Watch the diagnostic workflow end-to-end.




  

    
RDebug a broken revenue report

    
# A real-world messy CSV-style data frame
revenue_df <- data.frame(
  region     = c("North", "South", "East", "West"),
  units_sold = c("1,200", "950", "2,100", "1,450"),
  unit_price = c("$19.99", "$24.50", "$15.00", "$22.75"),
  discount   = factor(c("0.05", "0.10", "0.00", "0.15")),
  stringsAsFactors = FALSE
)

# Step 1, scan every column at once
sapply(revenue_df, class)
#>     region units_sold unit_price   discount
#> "character" "character" "character"   "factor"

# Step 2, identify the non-numeric columns we want to fix
bad <- c("units_sold", "unit_price", "discount")

# Step 3, fix each pattern
revenue_df$units_sold <- parse_number(revenue_df$units_sold)
revenue_df$unit_price <- parse_number(revenue_df$unit_price)
revenue_df$discount   <- as.numeric(as.character(revenue_df$discount))

# Step 4, compute revenue after discount
revenue_df$revenue <- with(revenue_df,
  units_sold * unit_price * (1 - discount)
)

print(revenue_df)
#>   region units_sold unit_price discount  revenue
#> 1  North       1200      19.99     0.05 22788.60
#> 2  South        950      24.50     0.10 20947.50
#> 3   East       2100      15.00     0.00 31500.00
#> 4   West       1450      22.75     0.15 28035.31

# Grand total
sum(revenue_df$revenue)
#> [1] 103271.41

    

      
      
    

    

  

  





Four commands, four patches, one grand total. The key is that the sapply() scan in Step 1 told us exactly which columns needed which treatment before we wrote a single fix, no guessing, no re-running, no error messages to decode.



Note
Prevention beats diagnosis. When reading CSVs with readr::read_csv(), pass col_types = cols(units_sold = col_number(), unit_price = col_number()) to parse numeric columns correctly at import time. Most of these errors never happen if the data enters R with the right types.



Summary



Diagnostic flow for 'non-numeric argument to binary operator'



Figure 1: Diagnostic flow for the 'non-numeric argument to binary operator' error.







Symptom
Diagnosis
Fix
Prevention






Error on x * y
class(x) returns "character"
as.numeric(x)
Check types after every data import




Error on df$col * k
sapply(df, is.numeric) flags the column
parse_number() or as.numeric()
Use col_types in read_csv()




Wrong numbers after converting a factor
class(x) returns "factor"
as.numeric(as.character(x))
Avoid factors on numeric-looking columns




Single NA after as.numeric()
A hidden "N/A", "$", or whitespace
parse_number(x, na = "N/A")
Clean strings before arithmetic




Mystery failure in wide data
names(df)[!sapply(df, is.numeric)]
Loop fixes with lapply()
Validate with stopifnot(sapply(df, is.numeric))







References



    


  1. R Core Team, R Language Definition, Operators. Link
    2. 


  2. Wickham, H., Advanced R (2nd ed.), Chapter 3: Vectors. Link
    3. 


  3. readr, parse_number() reference. Link
    4. 


  4. R Core Team, R FAQ: as.numeric() on a factor. Link
    5. 


  5. R Documentation, base::class(). Link
    6. 


  6. Wickham, H., Tidyverse Style Guide. Link
    7. 


  7. Posit Community, "non-numeric argument to binary operator" thread. Link
    8. 





Continue Learning



    


  1. R Errors Decoded: Plain-English Explanations and Exact Fixes, the parent reference for all 50 common R errors. R-Common-Errors.html
    2. 


  2. R Warning: NAs introduced by coercion, what happens after as.numeric() silently fails on bad values. R-Warning-NAs-Introduced-By-Coercion.html
    3. 


  3. R Error: object 'x' not found, when the variable name itself is the problem, not its type. R-Error-Object-Not-Found.html
    4. 




Related Tutorials
ggplot2 'object not found': Is It a Column Name or an R Variable?7 min readR solve() Error: 'singular matrix', Diagnose Multicollinearity and Fix It9 min readRStan 'failed to compile' Error, Every Known Fix in One Place8 min readR Error: 'replacement has length zero', The Hidden NA That Breaks Assignment7 min read


        


        
      


      

        

        
© 2016-2026 Selva Prabhakaran.
          This work is licensed under the Creative Commons License.