assignment operator r package

Secure Your Spot in Our Statistical Methods in R Online Course Starting on September 9 (Click for More Info)

Assignment Operators in R (3 Examples) | Comparing = vs. ＜- vs. ＜＜-

On this page you’ll learn how to apply the different assignment operators in the R programming language .

The content of the article is structured as follows:

Let’s dive right into the exemplifying R syntax!

Example 1: Why You Should Use ＜- Instead of = in R

Generally speaking, there is a preference in the R programming community to use an arrow (i.e. ＜-) instead of an equal sign (i.e. =) for assignment.

In my opinion, it makes a lot of sense to stick to this convention to produce scripts that are easy to read for other R programmers.

However, you should also take care about the spacing when assigning in R. False spacing can even lead to error messages .

For instance, the following R code checks whether x is smaller than minus five due to the false blank between ＜ and -:

A properly working assignment could look as follows:

However, this code is hard to read, since the missing space makes it difficult to differentiate between the different symbols and numbers.

In my opinion, the best way to assign in R is to put a blank before and after the assignment arrow:

As mentioned before, the difference between ＜- and = is mainly due to programming style . However, the following R code using an equal sign would also work:

In the following example, I’ll show a situation where ＜- and = do not lead to the same result. So keep on reading!

Example 2: When ＜- is Really Different Compared to =

In this Example, I’ll illustrate some substantial differences between assignment arrows and equal signs.

Let’s assume that we want to compute the mean of a vector ranging from 1 to 5. Then, we could use the following R code:

However, if we want to have a look at the vector x that we have used within the mean function, we get an error message:

Let’s compare this to exactly the same R code but with assignment arrow instead of an equal sign:

The output of the mean function is the same. However, the assignment arrow also stored the values in a new data object x:

This example shows a meaningful difference between = and ＜-. While the equal sign doesn’t store the used values outside of a function, the assignment arrow saves them in a new data object that can be used outside the function.

Example 3: The Difference Between ＜- and ＜＜-

So far, we have only compared ＜- and =. However, there is another assignment method we have to discuss: The double assignment arrow ＜＜- (also called scoping assignment).

The following code illustrates the difference between ＜- and ＜＜- in R. This difference mainly gets visible when applying user-defined functions .

Let’s manually create a function that contains a single assignment arrow:

Now, let’s apply this function in R:

The data object x_fun1, to which we have assigned the value 5 within the function, does not exist:

Let’s do the same with a double assignment arrow:

Let’s apply the function:

And now let’s return the data object x_fun2:

As you can see based on the previous output of the RStudio console, the assignment via ＜＜- saved the data object in the global environment outside of the user-defined function.

Video & Further Resources

I have recently released a video on my YouTube channel , which explains the R syntax of this tutorial. You can find the video below:

The YouTube video will be added soon.

In addition to the video, I can recommend to have a look at the other articles on this website.

• R Programming Examples

In summary: You learned on this page how to use assignment operators in the R programming language. If you have further questions, please let me know in the comments.

assignment-operators-in-r How to use different assignment operators in R – 3 R programming examples – R programming language tutorial – Actionable R programming syntax in RStudio

Subscribe to the Statistics Globe Newsletter

Get regular updates on the latest tutorials, offers & news at Statistics Globe. I hate spam & you may opt out anytime: Privacy Policy .

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Post Comment

I’m Joachim Schork. On this website, I provide statistics tutorials as well as code in Python and R programming.

Statistics Globe Newsletter

Get regular updates on the latest tutorials, offers & news at Statistics Globe. I hate spam & you may opt out anytime: Privacy Policy .

Related Tutorials

Introduction to the random Package in R (3 Examples)

Solve System of Equations in R (3 Examples) | Using solve() Function

roperators Additional Operators to Help you Write Cleaner R Code

• Make your R code nicer with roperators
• assign_by_regex: Assign to vector only where regular expression is matched
• assign_ops: Assignment operators
• choose_permute: Choose and permute
• cleaner_conversions: Cleaner conversion functions
• comparisons: Enhanced comparisons
• complete_cases: Statistics/Summaries with (Only) Missing Data Removed
• content_checks: Contents of Vector Checks
• factor_conversion: Convert factor with numeric labels into numeric vector
• file_checks: File Extension Checks
• floating_point_comparisons: Floating point comparison operators
• integrate: Inline integration
• library.force: loads package if available, else tries to install it (from...
• logicals: Logical operators
• os: Operating system checks
• overwrite_by_regex: Modify existing object by regular expression
• overwrite_missing: Assign value to a vector's missing values
• paste_and_cat: New Paste and Cat Rules
• read.tsv: like read.csv, but for tsv and default header = TRUE
• string_arithmetic: String operators
• time_savers: Little functions to replace common minor functions. useful in...
• type_checks: Type Checks
• Browse all...

assign_ops : Assignment operators In roperators: Additional Operators to Help you Write Cleaner R Code

Assignment operators

Description.

Modifies the stored value of the left-hand-side object by the right-hand-side object. Equivalent of operators such as += -= *= /= in languages like c++ or python. %+=% and %-=% can also work with strings.

Ben Wiseman, [email protected]

Related to assign_ops in roperators ...

R package documentation, browse r packages, we want your feedback.

Add the following code to your website.

REMOVE THIS Copy to clipboard

For more information on customizing the embed code, read Embedding Snippets .

Assignment Operators

Description.

Assign a value to a name.

There are three different assignment operators: two of them have leftwards and rightwards forms.

The operators <- and = assign into the environment in which they are evaluated. The operator <- can be used anywhere, whereas the operator = is only allowed at the top level (e.g., in the complete expression typed at the command prompt) or as one of the subexpressions in a braced list of expressions.

The operators <<- and ->> cause a search to made through the environment for an existing definition of the variable being assigned. If such a variable is found then its value is redefined, otherwise assignment takes place globally. Note that their semantics differ from that in the S language, but are useful in conjunction with the scoping rules of R . See ‘The R Language Definition’ manual for further details and examples.

In all the assignment operator expressions, x can be a name or an expression defining a part of an object to be replaced (e.g., z[[1]] ). The name does not need to be quoted, though it can be.

The leftwards forms of assignment <- = <<- group right to left, the other from left to right.

value . Thus one can use a <- b <- c <- 6 .

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language . Wadsworth & Brooks/Cole.

Chamber, J. M. (1998) Programming with Data. A Guide to the S Language . Springer (for = ).

assign , environment .

Assignment Operators in R

R provides two operators for assignment: <- and = .

Understanding their proper use is crucial for writing clear and readable R code.

Using the <- Operator

For assignments.

The <- operator is the preferred choice for assigning values to variables in R.

It clearly distinguishes assignment from argument specification in function calls.

Readability and Tradition

• This usage aligns with R’s tradition and enhances code readability.

Using the = Operator

The = operator is commonly used to explicitly specify named arguments in function calls.

It helps in distinguishing argument assignment from variable assignment.

Assignment Capability

• While = can also be used for assignment, this practice is less common and not recommended for clarity.

Mixing Up Operators

Potential confusion.

Using = for general assignments can lead to confusion, especially when reading or debugging code.

Mixing operators inconsistently can obscure the distinction between assignment and function argument specification.

• In the example above, x = 10 might be mistaken for a function argument rather than an assignment.

Best Practices Recap

Consistency and clarity.

Use <- for variable assignments to maintain consistency and clarity.

Reserve = for specifying named arguments in function calls.

Avoiding Common Mistakes

Be mindful of the context in which you use each operator to prevent misunderstandings.

Consistently using the operators as recommended helps make your code more readable and maintainable.

Quiz: Assignment Operator Best Practices

Which of the following examples demonstrates the recommended use of assignment operators in R?

• my_var = 5; mean(x = my_var)
• my_var <- 5; mean(x <- my_var)
• my_var <- 5; mean(x = my_var)
• my_var = 5; mean(x <- my_var)
• The correct answer is 3 . my_var <- 5; mean(x = my_var) correctly uses <- for variable assignment and = for specifying a named argument in a function call.

Introduction

• R installation
• Working directory
• Getting help
• Install packages

Data structures

Data Wrangling

• Sort and order
• Merge data frames

Programming

• Creating functions
• If else statement
• apply function
• sapply function
• tapply function

Import & export

• Read TXT files
• Import CSV files
• Read Excel files
• Read SQL databases
• Export data
• plot function
• Scatter plot
• Density plot
• Tutorials Introduction Data wrangling Graphics Statistics See all

R operators

There are several operators in R, such that arithmetic operators for math calculations, logical, relational or assignment operators or even the popular pipe operator. In this tutorial we will show you the R operators divided into operator types. In addition, we will show examples of use of every operator.

Arithmetic operators

The R arithmetic operators allows us to do math operations , like sums, divisions or multiplications, among others. The following table summarizes all base R arithmetic operators.

In the next block of code you will find examples of basic calculations with arithmetic operations with integers.

You can also use the basic operations with R vectors of the same length . Note that the result of these operations will be a vector with element-wise operation results.

Furthermore, you can use those arithmetic operators with matrix objects, besides the ones designed for this type of object (matrix multiplication types). Check our tutorial about matrix operations to learn more.

Logical / boolean operators

In addition, boolean or logical operators in R are used to specify multiple conditions between objects. These comparisons return TRUE and FALSE values.

Relational / comparison operators in R

Comparison or relational operators are designed to compare objects and the output of these comparisons are of type boolean. To clarify, the following table summarizes the R relational operators.

For example, you can compare integer values with these operators as follows.

If you compare vectors the output will be other vector of the same length and each element will contain the boolean corresponding to the comparison of the corresponding elements (the first element of the first vector with the first element of the second vector and so on). Moreover, you can compare each element of a matrix against other.

Assignment operators in R

The assignment operators in R allows you to assign data to a named object in order to store the data .

Note that in almost scripting programming languages you can just use the equal (=) operator. However, in R it is recommended to use the arrow assignment ( <- ) and use the equal sign only to set arguments.

The arrow assignment can be used as left or right assignment, but the right assignment is not generally used. In addition, you can use the double arrow assignment, known as scoping assignment, but we won’t enter in more detail in this tutorial, as it is for advanced users. You can know more about this assignment operator in our post about functions in R .

In the following code block you will find some examples of these operators.

If you need to use the right assignment remember that the object you want to store needs to be at the left, or an error will arise.

There are some rules when naming variables. For instance, you can use letters, numbers, dots and underscores in the variable name, but underscores can’t be the first character of the variable name.

Reserved words

There are also reserved words you can’t use, like TRUE , FALSE , NULL , among others. You can see the full list of R reserved words typing help(Reserved) or ?Reserved .

However, if for some reason you need to name your variable with a reserved word or starting with an underscore you will need to use backticks:

Miscellaneous R operators

Miscellaneous operators in R are operators used for specific purposes , as accessing data, functions, creating sequences or specifying a formula of a model. To clarify, the next table contains all the available miscellaneous operators in R.

In addition, in the following block of code we show several examples of these operators:

Infix operator

You can call an operator as a function . This is known as infix operators. Note that this type of operators are not generally used or needed.

Pipe operator in R

The pipe operator is an operator you can find in several libraries, like dplyr . The operator can be read as ‘AND THEN’ and its purpose is to simplify the syntax when writing R code. As an example, you could subset the cars dataset and then create a summary of the subset with the following code:

Explore and discover thousands of packages, functions and datasets

Learn how to plot your data in R with the base package and ggplot2

PYTHON CHARTS

Learn how to create plots in Python with matplotlib, seaborn, plotly and folium

Related content

Convert objects to numeric with as.numeric()

Introduction to R

Use the as.numeric function in R to coerce objects to numeric and learn how to check if an object is numeric with is.numeric

Obtain HELP in R of PACKAGES and FUNCTIONS ✅ Download FREE R BOOKS and MANUALS, view DEMOS, EXAMPLES, R vignettes, datasets info and find ONLINE resources

head and tail functions in R

R introduction

The head and tail functions in R are useful to show the first or last elements or rows of an R object

Try adjusting your search query

👉 If you haven’t found what you’re looking for, consider clicking the checkbox to activate the extended search on R CHARTS for additional graphs tutorials, try searching a synonym of your query if possible (e.g., ‘bar plot’ -> ‘bar chart’), search for a more generic query or if you are searching for a specific function activate the functions search or use the functions search bar .

Multiple assignment operators

Description.

Assign values to name(s).

%<-% and %->% invisibly return value .

These operators are used primarily for their assignment side-effect. %<-% and %->% assign into the environment in which they are evaluated.

Name Structure

At its simplest, the name structure may be a single variable name, in which case %<-% and %->% perform regular assignment, x %<-% list(1, 2, 3) or list(1, 2, 3) %->% x .

To specify multiple variable names use a call to c() , for example c(x, y, z) %<-% c(1, 2, 3) .

When value is neither an atomic vector nor a list, %<-% and %->% will try to destructure value into a list before assigning variables, see destructure() .

object parts

Like assigning a variable, one may also assign part of an object, c(x, x[[1]]) %<-% list(list(), 1) .

nested names

One can also nest calls to c() when needed, c(x, c(y, z)) . This nested structure is used to unpack nested values, c(x, c(y, z)) %<-% list(1, list(2, 3)) .

collector variables

To gather extra values from the beginning, middle, or end of value use a collector variable. Collector variables are indicated with a ... prefix, c(...start, z) %<-% list(1, 2, 3, 4) .

skipping values

Use . in place of a variable name to skip a value without raising an error or assigning the value, c(x, ., z) %<-% list(1, 2, 3) .

Use ... to skip multiple values without raising an error or assigning the values, c(w, ..., z) %<-% list(1, NA, NA, 4) .

default values

Use = to specify a default value for a variable, c(x, y = NULL) %<-% tail(1, 2) .

When assigning part of an object a default value may not be specified because of the syntax enforced by R . The following would raise an "unexpected '=' ..." error, c(x, x[[1]] = 1) %<-% list(list()) .

For more on unpacking custom objects please refer to destructure() .

Introduction to R

Assignment operators.

You can assign values or functions to R objects using <- operator.

Assignment Operators

Description.

Assign a value to a name.

There are three different assignment operators: two of them have leftwards and rightwards forms.

The operators <- and = assign into the environment in which they are evaluated. The operator <- can be used anywhere, whereas the operator = is only allowed at the top level (e.g., in the complete expression typed at the command prompt) or as one of the subexpressions in a braced list of expressions.

The operators <<- and ->> are normally only used in functions, and cause a search to made through parent environments for an existing definition of the variable being assigned. If such a variable is found (and its binding is not locked) then its value is redefined, otherwise assignment takes place in the global environment. Note that their semantics differ from that in the S language, but are useful in conjunction with the scoping rules of R . See ‘The R Language Definition’ manual for further details and examples.

In all the assignment operator expressions, x can be a name or an expression defining a part of an object to be replaced (e.g., z[[1]] ). A syntactic name does not need to be quoted, though it can be (preferably by backtick s).

The leftwards forms of assignment <- = <<- group right to left, the other from left to right.

value . Thus one can use a <- b <- c <- 6 .

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language . Wadsworth & Brooks/Cole.

Chamber, J. M. (1998) Programming with Data. A Guide to the S Language . Springer (for = ).

assign , for “subassignment” such as x[i] <- v , [<- ; environment .

Data Science and Engineering at ThinkR . 'Chaotic good developer'. International Speaker. Runs. Eats plants.

Navigation:

• Custom Social Profile Link
• 🏡 Home
• ✍ Blog
• 🤘 About
• 📢 Talks & Publications
• 💾 Open Source
• 📙 Engineering Shiny
• 🔎 Search

Why do we use arrow as an assignment operator?

5 minute(s) read

A Twitter Thread turned into a blog post.

In June, I published a little thread on Twitter about the history of the <- assignment operator in R. Here is a blog post version of this thread.

Historical reasons

As you all know, R comes from S. But you might not know a lot about S (I don’t). This language used <- as an assignment operator. It’s partly because it was inspired by a language called APL, which also had this sign for assignment.

But why again? APL was designed on a specific keyboard, which had a key for <- :

At that time, it was also chosen because there was no == for testing equality: equality was tested with = , so assigning a variable needed to be done with another symbol.

From APL Reference Manual

Until 2001 , in R, = could only be used for assigning function arguments, like fun(foo = "bar") (remember that R was born in 1993). So before 2001, the <- was the standard (and only way) to assign value into a variable.

Before that, _ was also a valid assignment operator. It was removed in R 1.8 :

(So no, at that time, no snake_case_naming_convention)

Colin Gillespie published some of his code from early 2000 , where assignment was made like this :)

The main reason “equal assignment” was introduced is because other languages uses = as an assignment method, and because it increased compatibility with S-Plus.

Readability

Nowadays, there are seldom any cases when you can’t use one in place of the other. It’s safe to use = almost everywhere. Yet, <- is preferred and advised in R Coding style guides:

• https://google.github.io/styleguide/Rguide.xml#assignment
• http://adv-r.had.co.nz/Style.html

One reason, if not historical, to prefer the <- is that it clearly states in which side you are making the assignment (you can assign from left to right or from right to left in R):

The RHS assignment can for example be used for assigning the result of a pipe

Also, it’s easier to distinguish equality comparison and assignment in the last line of code here:

Note that <<- and ->> also exist:

And that Ross Ihaka uses = : https://www.stat.auckland.ac.nz/~ihaka/downloads/JSM-2010.pdf

Environments

There are some environment and precedence differences. For example, assignment with = is only done on a functional level, whereas <- does it on the top level when called inside as a function argument.

In the first code, you’re passing x as the parameter of the median function, whereas the second one is creating a variable x in the environment, and uses it as the first argument of median . Note that it works because x is the name of the parameter of the function, and won’t work with y :

There is also a difference in parsing when it comes to both these operators (but I guess this never happens in the real world), one failing and not the other:

It is also good practice because it clearly indicates the difference between function arguments and assignation:

And this weird behavior:

Little bit unrelated but

I love this one:

Which of course is not doable with = .

Other operators

Some users pointed out on Twitter that this could make the code a little bit harder to read if you come from another language. <- is use “only” use in F#, OCaml, R and S (as far as Wikipedia can tell). Even if <- is rare in programming, I guess its meaning is quite easy to grasp, though.

Note that the second most used assignment operator is := ( = being the most common). It’s used in {data.table} and {rlang} notably. The := operator is not defined in the current R language, but has not been removed, and is still understood by the R parser. You can’t use it on the top level:

But as it is still understood by the parser, you can use := as an infix without any %%, for assignment, or for anything else:

You can see that := was used as an assignment operator https://developer.r-project.org/equalAssign.html :

All the previously allowed assignment operators (<-, :=, _, and <<-) remain fully in effect

Or in R NEWS 1:

• Around 29’: https://channel9.msdn.com/Events/useR-international-R-User-conference/useR2016/Forty-years-of-S
• Use = or <- for assignment?
• What are the differences between “=” and “<-” in R?
• Assignment Operators

What do you think?

The machine thinks you might also like:.

• webrcli & spidyr: What’s new — 2024-07-10

Find all my posts about webR here. Note: the first post of this series explaining roughly what webR is, I won’t introduce it again here. In this blogpo...

• webrcli & spidyr: A starter pack for building NodeJS projects with webR inside — 2024-03-06

Find all my posts about webR here. Note: the first post of this series explaining roughly what webR is, I won’t introduce it again here. Again, a new p...

• Rethinking packages & functions preloading in webR 0.2.2 — 2023-11-24

Find all my posts about webR here. Note: the first post of this series explaining roughly what webR is, I won’t introduce it again here. When I wrote m...

• Using my own R functions in webR in an Express JS API, and thoughts on building web apps with Node & webR — 2023-10-17

Find all my posts about webR here. Note: the first post of this series explaining roughly what webR is, I won’t introduce it again here. Note 2: web...

assign: Assign a Value to a Name

Description.

Assign a value to a name in an environment.

a variable name, given as a character string. No coercion is done, and the first element of a character vector of length greater than one will be used, with a warning.

a value to be assigned to x .

where to do the assignment. By default, assigns into the current environment. See ‘Details’ for other possibilities.

the environment to use. See ‘Details’.

should the enclosing frames of the environment be inspected?

an ignored compatibility feature.

This function is invoked for its side effect, which is assigning value to the variable x . If no envir is specified, then the assignment takes place in the currently active environment.

If inherits is TRUE , enclosing environments of the supplied environment are searched until the variable x is encountered. The value is then assigned in the environment in which the variable is encountered (provided that the binding is not locked: see lockBinding : if it is, an error is signaled). If the symbol is not encountered then assignment takes place in the user's workspace (the global environment).

If inherits is FALSE , assignment takes place in the initial frame of envir , unless an existing binding is locked or there is no existing binding and the environment is locked (when an error is signaled).

There are no restrictions on the name given as x : it can be a non-syntactic name (see make.names ).

The pos argument can specify the environment in which to assign the object in any of several ways: as -1 (the default), as a positive integer (the position in the search list); as the character string name of an element in the search list; or as an environment (including using sys.frame to access the currently active function calls). The envir argument is an alternative way to specify an environment, but is primarily for back compatibility.

assign does not dispatch assignment methods, so it cannot be used to set elements of vectors, names, attributes, etc.

Note that assignment to an attached list or data frame changes the attached copy and not the original object: see attach and with .

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language . Wadsworth & Brooks/Cole.

<- , get , the inverse of assign() , exists , environment .

Run the code above in your browser using DataLab

• Data Visualization
• Statistics in R
• Machine Learning in R
• Data Science in R
• Packages in R

R Operators

Operators are the symbols directing the compiler to perform various kinds of operations between the operands. Operators simulate the various mathematical, logical, and decision operations performed on a set of Complex Numbers, Integers, and Numericals as input operands. 

R Operators 

R supports majorly four kinds of binary operators between a set of operands. In this article, we will see various types of operators in R Programming language and their usage.

Types of the operator in R language

Arithmetic Operators

Logical operators, relational operators, assignment operators, miscellaneous operators.

Arithmetic Operators modulo using the specified operator between operands, which may be either scalar values, complex numbers, or vectors. The R operators are performed element-wise at the corresponding positions of the vectors. 

Addition operator (+)

The values at the corresponding positions of both operands are added. Consider the following R operator snippet to add two vectors:

a <- c ( 1 , 0.1 ) b <- c ( 2.33 , 4 ) print ( a + b )

Output : 3.33 4.10

Subtraction Operator (-)

The second operand values are subtracted from the first. Consider the following R operator snippet to subtract two variables:

a <- 6 b <- 8.4 print ( a - b )

Output : -2.4

Multiplication Operator (*)  

The multiplication of corresponding elements of vectors and Integers are multiplied with the use of the ‘*’ operator.

B = c ( 4 , 4 ) C = c ( 5 , 5 ) print ( B * C )

Output : 20 20

Division Operator (/)  

The first operand is divided by the second operand with the use of the ‘/’ operator.

a <- 10 b <- 5 print ( a / b )

Power Operator (^)

The first operand is raised to the power of the second operand.

a <- 4 b <- 5 print ( a ^ b )

Output : 1024

Modulo Operator (%%)

The remainder of the first operand divided by the second operand is returned.

list1 <- c ( 2 , 22 ) list2 <- c ( 2 , 4 ) print ( list1 %% list2 )

Output : 0 2

The following R code illustrates the usage of all Arithmetic R operators.

# R program to illustrate # the use of Arithmetic operators vec1 <- c ( 0 , 2 ) vec2 <- c ( 2 , 3 ) # Performing operations on Operands cat ( "Addition of vectors :" , vec1 + vec2 , "\n" ) cat ( "Subtraction of vectors :" , vec1 - vec2 , "\n" ) cat ( "Multiplication of vectors :" , vec1 * vec2 , "\n" ) cat ( "Division of vectors :" , vec1 / vec2 , "\n" ) cat ( "Modulo of vectors :" , vec1 %% vec2 , "\n" ) cat ( "Power operator :" , vec1 ^ vec2 )

Output  

Addition of vectors : 2 5 Subtraction of vectors : -2 -1 Multiplication of vectors : 0 6 Division of vectors : 0 0.6666667 Modulo of vectors : 0 2 Power operator : 0 8

Logical Operators in R simulate element-wise decision operations, based on the specified operator between the operands, which are then evaluated to either a True or False boolean value. Any non-zero integer value is considered as a TRUE value, be it a complex or real number. 

Element-wise Logical AND operator (&)

Returns True if both the operands are True.

list1 <- c ( TRUE , 0.1 ) list2 <- c ( 0 , 4+3i ) print ( list1 & list2 )

Output : FALSE TRUE Any non zero integer value is considered as a TRUE value, be it complex or real number.

Element-wise Logical OR operator (|)

Returns True if either of the operands is True.

list1 <- c ( TRUE , 0.1 ) list2 <- c ( 0 , 4+3i ) print ( list1 | list2 )

Output : TRUE TRUE

NOT operator (!)

A unary operator that negates the status of the elements of the operand.

list1 <- c ( 0 , FALSE ) print ( ! list1 )

Logical AND operator (&&)

Returns True if both the first elements of the operands are True.

list1 <- c ( TRUE , 0.1 ) list2 <- c ( 0 , 4+3i ) print ( list1 [ 1 ] && list2 [ 1 ])

Output : FALSE Compares just the first elements of both the lists.

Logical OR operator (||)

Returns True if either of the first elements of the operands is True.

list1 <- c ( TRUE , 0.1 ) list2 <- c ( 0 , 4+3i ) print ( list1 [ 1 ] || list2 [ 1 ])

Output : TRUE

The following R code illustrates the usage of all Logical Operators in R:  

# R program to illustrate # the use of Logical operators vec1 <- c ( 0 , 2 ) vec2 <- c ( TRUE , FALSE ) # Performing operations on Operands cat ( "Element wise AND :" , vec1 & vec2 , "\n" ) cat ( "Element wise OR :" , vec1 | vec2 , "\n" ) cat ( "Logical AND :" , vec1 [ 1 ] && vec2 [ 1 ], "\n" ) cat ( "Logical OR :" , vec1 [ 1 ] || vec2 [ 1 ], "\n" ) cat ( "Negation :" , ! vec1 )

Element wise AND : FALSE FALSE Element wise OR : TRUE TRUE Logical AND : FALSE Logical OR : TRUE Negation : TRUE FALSE

The Relational Operators in R carry out comparison operations between the corresponding elements of the operands. Returns a boolean TRUE value if the first operand satisfies the relation compared to the second. A TRUE value is always considered to be greater than the FALSE. 

Less than (<)

Returns TRUE if the corresponding element of the first operand is less than that of the second operand. Else returns FALSE.

list1 <- c ( TRUE , 0.1 , "apple" ) list2 <- c ( 0 , 0.1 , "bat" ) print ( list1 < list2 )

Output : FALSE FALSE TRUE

Less than equal to (<=)

Returns TRUE if the corresponding element of the first operand is less than or equal to that of the second operand. Else returns FALSE.

list1 <- c ( TRUE , 0.1 , "apple" ) list2 <- c ( TRUE , 0.1 , "bat" ) # Convert lists to character strings list1_char <- as.character ( list1 ) list2_char <- as.character ( list2 ) # Compare character strings print ( list1_char <= list2_char )

Output : TRUE TRUE TRUE

Greater than (>)

Returns TRUE if the corresponding element of the first operand is greater than that of the second operand. Else returns FALSE.

list1 <- c ( TRUE , 0.1 , "apple" ) list2 <- c ( TRUE , 0.1 , "bat" ) print ( list1_char > list2_char )

Output : FALSE FALSE FALSE

Greater than equal to (>=)

Returns TRUE if the corresponding element of the first operand is greater or equal to that of the second operand. Else returns FALSE.

list1 <- c ( TRUE , 0.1 , "apple" ) list2 <- c ( TRUE , 0.1 , "bat" ) print ( list1_char >= list2_char )

Output : TRUE TRUE FALSE

Not equal to (!=)  

Returns TRUE if the corresponding element of the first operand is not equal to the second operand. Else returns FALSE.

list1 <- c ( TRUE , 0.1 , 'apple' ) list2 <- c ( 0 , 0.1 , "bat" ) print ( list1 != list2 )

Output : TRUE FALSE TRUE

The following R code illustrates the usage of all Relational Operators in R:

# R program to illustrate # the use of Relational operators vec1 <- c ( 0 , 2 ) vec2 <- c ( 2 , 3 ) # Performing operations on Operands cat ( "Vector1 less than Vector2 :" , vec1 < vec2 , "\n" ) cat ( "Vector1 less than equal to Vector2 :" , vec1 <= vec2 , "\n" ) cat ( "Vector1 greater than Vector2 :" , vec1 > vec2 , "\n" ) cat ( "Vector1 greater than equal to Vector2 :" , vec1 >= vec2 , "\n" ) cat ( "Vector1 not equal to Vector2 :" , vec1 != vec2 , "\n" )

Vector1 less than Vector2 : TRUE TRUE Vector1 less than equal to Vector2 : TRUE TRUE Vector1 greater than Vector2 : FALSE FALSE Vector1 greater than equal to Vector2 : FALSE FALSE Vector1 not equal to Vector2 : TRUE TRUE

Assignment Operators in R are used to assigning values to various data objects in R. The objects may be integers, vectors, or functions. These values are then stored by the assigned variable names. There are two kinds of assignment operators: Left and Right

Left Assignment (<- or <<- or =)

Assigns a value to a vector.

vec1 = c ( "ab" , TRUE ) print ( vec1 )

Output : "ab" "TRUE"

Right Assignment (-> or ->>)

Assigns value to a vector.

c ( "ab" , TRUE ) ->> vec1 print ( vec1 )

# R program to illustrate # the use of Assignment operators vec1 <- c ( 2 : 5 ) c ( 2 : 5 ) ->> vec2 vec3 <<- c ( 2 : 5 ) vec4 = c ( 2 : 5 ) c ( 2 : 5 ) -> vec5 # Performing operations on Operands cat ( "vector 1 :" , vec1 , "\n" ) cat ( "vector 2 :" , vec2 , "\n" ) cat ( "vector 3 :" , vec3 , "\n" ) cat ( "vector 4 :" , vec4 , "\n" ) cat ( "vector 5 :" , vec5 )

vector 1 : 2 3 4 5 vector 2 : 2 3 4 5 vector 3 : 2 3 4 5 vector 4 : 2 3 4 5 vector 5 : 2 3 4 5

Miscellaneous Operator are the mixed operators in R that simulate the printing of sequences and assignment of vectors, either left or right-handed. 

%in% Operator  

Checks if an element belongs to a list and returns a boolean value TRUE if the value is present  else FALSE.

val <- 0.1 list1 <- c ( TRUE , 0.1 , "apple" ) print ( val %in% list1 )

Output : TRUE Checks for the value 0.1 in the specified list. It exists, therefore, prints TRUE.

%*% Operator

This operator is used to multiply a matrix with its transpose. Transpose of the matrix is obtained by interchanging the rows to columns and columns to rows. The number of columns of the first matrix must be equal to the number of rows of the second matrix. Multiplication of the matrix A with its transpose, B, produces a square matrix.  [Tex]A_{r*c} x B_c*r -> P_{r*r}  [/Tex]

mat = matrix ( c ( 1 , 2 , 3 , 4 , 5 , 6 ), nrow = 2 , ncol = 3 ) print ( mat ) print ( t ( mat )) pro = mat %*% t ( mat ) print ( pro )

Input : Output :[,1] [,2] [,3] #original matrix of order 2x3 [1,] 1 3 5 [2,] 2 4 6 [,1] [,2] #transposed matrix of order 3x2 [1,] 1 2 [2,] 3 4 [3,] 5 6 [,1] [,2] #product matrix of order 2x2 [1,] 35 44 [2,] 44 56

The following R code illustrates the usage of all Miscellaneous Operators in R:

# R program to illustrate # the use of Miscellaneous operators mat <- matrix ( 1 : 4 , nrow = 1 , ncol = 4 ) print ( "Matrix elements using : " ) print ( mat ) product = mat %*% t ( mat ) print ( "Product of matrices" ) print ( product ,) cat ( "does 1 exist in prod matrix :" , "1" %in% product )

[1] "Matrix elements using : " [,1] [,2] [,3] [,4] [1,] 1 2 3 4 [1] "Product of matrices" [,1] [1,] 30 does 1 exist in prod matrix : FALSE

Please Login to comment...

Similar reads.

• SUMIF in Google Sheets with formula examples
• How to Get a Free SSL Certificate
• Best SSL Certificates Provider in India
• Elon Musk's xAI releases Grok-2 AI assistant
• Content Improvement League 2024: From Good To A Great Article

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

R news and tutorials contributed by hundreds of R bloggers

Global vs. local assignment operators in r (‘<<-’ vs. ‘<-’).

Posted on September 11, 2022 by Trevor French in R bloggers | 0 Comments

Understanding the difference between local and global assignment operators in R can be tricky to get your head around. Here’s an example which should clear things up.

First, let’s create two variables named “global_var” and “local_var” and give them the values “global” and “local”, respectively. Notice we are using the standard assignment operator “<-” for both variables.

Next, let’s create a function to test out the global assignment operator (“<<-”). Inside this function, we will assign a new value to both of the variables we just created; however, we will use the “<-” operator for the local_var and the “<<-” operator for the global_var so that we can observe the difference in behavior.

This function performs how you would expect it to intuitively, right? The interesting part comes next when we print out the values of these variables again.

From this result, we can see the difference in behavior caused by the differing assignment operators. When using the “<-” operator inside the function, it’s scope is limited to just the function that it lives in. On the other hand, the “<<-” operator has the ability to edit the value of the variable outside of the function as well.

Global vs. local assignment operators in R (‘ was originally published in Trevor French on Medium, where people are continuing the conversation by highlighting and responding to this story.

Copyright © 2022 | MH Corporate basic by MH Themes

Never miss an update! Subscribe to R-bloggers to receive e-mails with the latest R posts. (You will not see this message again.)

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How to use the `:=` operator in an R package?

I'm wondering how to accurately use the following command in an R package:

But when running the R CMD checks, I obviously get the problem that there is no function definition for := :

no visible global function definition for ':='

Any ideas how I can properly define this in a package? I already looked at the glue package and this:

But I can't seem to find a good way of dealing with this. Any ideas? Also happy to consider a work-around on the above that does not use the operator.

• 4 You may try #' @importFrom rlang := –  akrun Commented Feb 11, 2023 at 19:49
• 1 akrun's right, and make sure you update NAMESPACE , and have rlang in the Imports: section of your package DESCRIPTION (or CMD check will complain). –  r2evans Commented Feb 11, 2023 at 19:57
• Excellent, many thanks to you both - this worked! If you want to add it as an answer, I'll accept it as correct. –  Moritz Schwarz Commented Feb 11, 2023 at 21:26
• 1 You don't need a real definition for it, because it is never used. Just define something like ` ':=' <- function(x, y) stop(":= used out of context")` which is more or less what rlang does. –  user2554330 Commented Feb 11, 2023 at 21:55

The ':=' is a part of data.table package. To use this operator you need to load the data.table package in R. For example, in your example code, the := operator assigns dep to variable in a new column in your test dataset after unquoting your command and converting it to formula and applying it to test data saving the results of formula into variable column. Also probably you need to convert your test data to data.table format.

Hope it could helps

• Thanks SALAR, in this case I'm referring to the := operator from the rlang package. Would the example above also work with assigning the := operator from the data.table package? –  Moritz Schwarz Commented Feb 13, 2023 at 9:18
• @MoritzSchwarz Yes, it would also work for the ‘data.table’ package. –  Konrad Rudolph Commented Feb 14, 2023 at 14:00

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged r package or ask your own question .

• The Overflow Blog
• Where does Postgres fit in a world of GenAI and vector databases?
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation

Hot Network Questions

• My school wants me to download an SSL certificate to connect to WiFi. Can I just avoid doing anything private while on the WiFi?
• Do the amplitude and frequency of gravitational waves emitted by binary stars change as the stars get closer together?
• What would be non-slang equivalent of "copium"?
• Are quantum states like the W, Bell, GHZ, and Dicke state actually used in quantum computing research?
• Why did General Leslie Groves evade Robert Oppenheimer's question here?
• Does the Greek used in 1 Peter 3:7 properly translate as “weaker” and in what way might that be applied?
• What are the French verbs that have invariable past participles?
• How do you say "head tilt“ in Chinese?
• Story where character has "boomerdisc"
• How does \vdotswithin work?
• Using Thin Lens Equation to find how far 1972 Blue Marble photo was taken
• Looking for the meaning of a word in first verse of Rig Veda
• Exact time point of assignment
• Dress code for examiner in UK PhD viva
• What happens if all nine Supreme Justices recuse themselves?
• My Hydraulic brakes are seizing up and I have tried everything. Help
• 3 Aspects of Voltage that contradict each other
• Which programming language/environment pioneered row-major array order?
• What explanations can be offered for the extreme see-sawing in Montana's senate race polling?
• Equations for dual cubic curves
• Why do National Geographic and Discovery Channel broadcast fake or pseudoscientific programs?
• Trying to find an old book (fantasy or scifi?) in which the protagonist and their romantic partner live in opposite directions in time
• Integral concerning the floor function
• Can a rope thrower act as a propulsion method for land based craft?