Difference between revisions of "RPR-Syntax basics"

From "A B C"
Jump to navigation Jump to search
m
m
Line 19: Line 19:
  
  
−
{{DEV}}
+
{{LIVE}}
  
 
{{Vspace}}
 
{{Vspace}}
Line 29: Line 29:
 
<section begin=abstract />
 
<section begin=abstract />
 
<!-- included from "../components/RPR-Syntax_basics.components.wtxt", section: "abstract" -->
 
<!-- included from "../components/RPR-Syntax_basics.components.wtxt", section: "abstract" -->
−
...
+
This unit discusses simple R commands and basic syntax, operators, and R objects (variables).
 
<section end=abstract />
 
<section end=abstract />
  
Line 50: Line 50:
 
=== Objectives ===
 
=== Objectives ===
 
<!-- included from "../components/RPR-Syntax_basics.components.wtxt", section: "objectives" -->
 
<!-- included from "../components/RPR-Syntax_basics.components.wtxt", section: "objectives" -->
−
...
+
This unit will ...
 +
* ... introduce basic operations of R syntax;
 +
* ... provide examples for use of operators;
 +
* ... discuss variable names.
  
 
{{Vspace}}
 
{{Vspace}}
Line 57: Line 60:
 
=== Outcomes ===
 
=== Outcomes ===
 
<!-- included from "../components/RPR-Syntax_basics.components.wtxt", section: "outcomes" -->
 
<!-- included from "../components/RPR-Syntax_basics.components.wtxt", section: "outcomes" -->
−
...
+
After working through this unit you ...
 +
* ... can evaluate R expressions by tyoing them on the console;
 +
* ... know how to write and debug complex R expressions using lots of parentheses;
 +
* ... are able to avoid common issues when choosing variable names.
  
 
{{Vspace}}
 
{{Vspace}}
Line 91: Line 97:
  
  
−
The '''R''' command line evaluates expressions. Expressions can contain constants, variables, operators and functions of the various datatypes that '''R''' recognizes.
+
The '''R''' command line evaluates '''expressions'''. Expressions can contain constants, variables, operators and functions of the various datatypes that '''R''' recognizes.
  
 
{{Vspace}}
 
{{Vspace}}
Line 102: Line 108:
 
{{task|1=
 
{{task|1=
  
−
Try the following operators on numbers:
+
OPen an RStudio session and try the following operators on numbers:
  
 
<source lang="rsplus">
 
<source lang="rsplus">
Line 117: Line 123:
 
# Logical operators return TRUE or FALSE
 
# Logical operators return TRUE or FALSE
 
#    Unary:
 
#    Unary:
−
! TRUE
+
TRUE
 +
FALSE
 +
! TRUE # read carefully: the "!" - "not" - is easily overlooked
 
! FALSE
 
! FALSE
  
Line 151: Line 159:
 
{{task|1=
 
{{task|1=
  
−
====Exercise====
+
;Practice
−
 
+
:Given the expression shown below, the value of lastNum is 9:
−
Given the expression shown below, the value of lastNum is 9:
 
  
 
<source lang="rsplus">
 
<source lang="rsplus">
 
numbers <- c(16, 20, 3, 5, 9)
 
numbers <- c(16, 20, 3, 5, 9)
−
lastNum <- tail(numbers, 1)
+
lastNum <- tail(numbers, 1)   # explain what this does
  
 
</source>
 
</source>
 
Write R expressions:
 
Write R expressions:
  
−
1) To check whether lastNum is under 6 or greater than 10
+
1) To check whether lastNum is less than 6 or greater than 10
  
−
2) To check whether lastNum is between 10 and 20, including 10 and excluding 20
+
2) To check whether lastNum is in the interval [10, 20). (By the rules of mathematical notation this means 10 is included but 20 is not).
  
−
3) To output TRUE if lastNum equals lastNum plus 1 divided by 2 from 1)  (Hint use parentheses)
+
3) To output TRUE if the following operation gives 2:
 +
* take lastNum
 +
* divide it by 7
 +
* subtract the integer part and the first digit after the decimal point (hint: multiply by 10, then integer division by 1 gives you ... what)
 +
* multiply by 100
 +
* integer divide by 1
 +
* take the third root
  
 +
(Hints: use lots of parentheses and compare the final result to 2. To debug, select parts of the code and execute separately. If the console gets stuck because it is expecting a closing parenthesis, and all you see is the "+" sign, simply press &lt;escape&gt; to abort evaluation.)
  
−
Solutions:
+
<div class="toccolours mw-collapsible mw-collapsed" style="width:800px">
 +
Check your answers (but don't cheat) ...
 +
<div class="mw-collapsible-content">
 
<source lang="rsplus">
 
<source lang="rsplus">
 
1) lastNum < 6 | lastNum > 10
 
1) lastNum < 6 | lastNum > 10
 
2) lastNum >= 10 & lastNum < 20
 
2) lastNum >= 10 & lastNum < 20
−
3) ((lastNum + 1) / 2) < 6 | ((lastNum + 1) / 2) > 10
+
3) ((((9/7) - ((((9/7) * 10) %/% 1 )/10)) * 100) %/% 1 )^(1/3) == 2
  
 
</source>
 
</source>
 +
 +
</div>
 +
</div>
 +
 
}}
 
}}
  
Line 181: Line 201:
 
===Variables===
 
===Variables===
  
−
 
+
In order to store the results of expressions and computations, you can freely assign them to variables<ref>We call these "variables" because of what function they perform in our code, the actually '''are''' R "objects".</ref>. Variables are created by '''R''' whenever you first use them (''i.e.'' space in memory is allocated to the variable and a value is stored in that space.) Variable names distinguish between upper case and lower case letters. There are a small number of reserved names that you are not allowed to redefine, and R syntax contains very small number of predefined constants, such as <code>pi</code>. However these constants can be overwritten - be careful: '''R''' will ''allow'' you to define <code>pi <- 3</code> but casually redefining the foundations of mathematics may lead to unintended consequences. Read more about variable names at:
−
In order to store the results of expressions and computations, you can freely assign them to variables. Variables are created by '''R''' whenever you first use them (''i.e.'' space in memory is allocated to the variable and a value is stored in that space.) Variable names distinguish between upper case and lower case letters. There are a small number of reserved names that you are not allowed to redefine, and a very small number of predefined constants, such as <code>pi</code>. However these constants can be overwritten - be careful: '''R''' will ''allow'' you to define <code>pi <- 3</code> but casually redefining the foundations of mathematics may lead to unintended consequences. Read more about variable names at:
 
  
 
  <source lang="rsplus">
 
  <source lang="rsplus">
Line 189: Line 208:
 
</source>
 
</source>
  
−
To assign a value to a constant, use the assignment operator {{c|&lt;-}}. This is the default way of assigning values in '''R'''. You could also use the <code>=</code> sign, but there are subtle differences. (See: {{c|?"&lt;-"}}). There is a variant of the assignment operator {{c|&lt;&lt;-}} which is sometimes used inside functions. It assigns to a global context. This is possible, but not preferred since it generates a side effect of a function.
+
To assign a value to a constant, use the assignment operator {{c|&lt;-}}. This is the default way of assigning values in '''R'''. You could also use the <code>=</code> sign, but there are subtle differences. (See: {{c|?"&lt;-"}}). There is a variant of the assignment operator {{c|&lt;&lt;-}} which is sometimes used inside functions. It assigns to a global context. This is possible, but not preferred since it generates a side effect of a function. Don't do this. Forget about  {{c|&lt;&lt;-}} again.
  
 
<source lang="rsplus">
 
<source lang="rsplus">
Line 205: Line 224:
 
Note that '''all''' of '''R''''s data types (as well as functions and other objects) can be assigned to variables.
 
Note that '''all''' of '''R''''s data types (as well as functions and other objects) can be assigned to variables.
  
−
There are very few syntactic restrictions on variable names ([http://stackoverflow.com/questions/9195718/variable-name-restrictions-in-r discussed eg. here]) but this does not mean esoteric names are good. For the sake of your sanity, use names that express the meaning of the variable, and that are unique. Many '''R''' developers use {{c|dotted.variable.names}}, some people use the {{c|pothole_style}}, my personal preference is to write {{c|camelCaseNames}}. And while the single letters {{c|c f n s Q}} are syntactically valid variable names, they coincide with commands for the debugger browser and will execute debugger commands, rather than displaying variable values when you are debugging. Finally, try not to use variable names that coincide with parameter names in functions. Alas, you see this often in code, but such code can be hard to read because the semantics of the actual argument versus the parameter name becomes obscured. It's just common sense really: don't call different things by the same name.
+
There are very few syntactic restrictions on variable names ([http://stackoverflow.com/questions/9195718/variable-name-restrictions-in-r discussed eg. here]) but this does not mean esoteric names are good. For the sake of your sanity, use names that express the meaning of the variable, and that are unique. Many '''R''' developers use {{c|dotted.variable.names}}, some people use the {{c|pothole_style}}, my personal preference is to write {{c|camelCaseNames}}. And while the single letters {{c|c f n s Q}} are syntactically valid variable names, they coincide with commands for the debugger browser and will execute debugger commands, rather than displaying variable values when you are debugging. Finally, try not to use variable names that are the same as parameter names in functions. Alas, you see this often in code, but such code can be hard to read because the semantics of the actual argument versus the parameter name becomes obscured. It's just common sense really: don't call different things by the same name.
  
 
<source lang="rsplus">
 
<source lang="rsplus">
Line 289: Line 308:
 
:2017-08-05
 
:2017-08-05
 
<b>Modified:</b><br />
 
<b>Modified:</b><br />
−
:2017-08-05
+
:2017-09-10
 
<b>Version:</b><br />
 
<b>Version:</b><br />
−
:0.1
+
:1.0
 
<b>Version history:</b><br />
 
<b>Version history:</b><br />
−
*0.1 First stub
+
*1.0 Completed to first live version
 +
*0.1 Material collected from previous tutorial
 
</div>
 
</div>
 
[[Category:ABC-units]]
 
[[Category:ABC-units]]

Revision as of 15:57, 10 September 2017

Basics of R syntax


 

Keywords:  Simple commands and basic syntax, operators, variables, class, mode, and attributes


 



 


 


Abstract

This unit discusses simple R commands and basic syntax, operators, and R objects (variables).


 


This unit ...

Prerequisites

You need to complete the following units before beginning this one:


 


Objectives

This unit will ...

  • ... introduce basic operations of R syntax;
  • ... provide examples for use of operators;
  • ... discuss variable names.


 


Outcomes

After working through this unit you ...

  • ... can evaluate R expressions by tyoing them on the console;
  • ... know how to write and debug complex R expressions using lots of parentheses;
  • ... are able to avoid common issues when choosing variable names.


 


Deliverables

  • Time management: Before you begin, estimate how long it will take you to complete this unit. Then, record in your course journal: the number of hours you estimated, the number of hours you worked on the unit, and the amount of time that passed between start and completion of this unit.
  • Journal: Document your progress in your Course Journal. Some tasks may ask you to include specific items in your journal. Don't overlook these.
  • Insights: If you find something particularly noteworthy about this unit, make a note in your insights! page.


 


Evaluation

Evaluation: NA

This unit is not evaluated for course marks.


 


Contents

Simple commands

The R command line evaluates expressions. Expressions can contain constants, variables, operators and functions of the various datatypes that R recognizes.


 

Operators

The common arithmetic operators are recognized in the usual way.

Task:
OPen an RStudio session and try the following operators on numbers: 

5
5 + 3
5 + 1 / 2 # Think first is this 3 or 5.5
3 * 2 + 1
3 * (2 + 1)
2^3 # Exponentiation
8 ^ (1/3) # Third root via exponentiation
7 %% 2  # Modulo operation (remainder of integer division)
7 %/% 2 # Integer division

# Logical operators return TRUE or FALSE
#    Unary:
TRUE
FALSE
! TRUE  # read carefully: the "!" - "not" - is easily overlooked
! FALSE

#    Binary

1 == 2
1 != 2
1 < 2
1 > 2

1 > 1
1 >= 1
1 < 1
1 <= 1

#    & AND
TRUE & TRUE
TRUE & FALSE
FALSE & FALSE

#    | OR
TRUE | TRUE
TRUE | FALSE
FALSE | FALSE

# Predict what this will return
!(FALSE | (! FALSE))


Task:

Practice
Given the expression shown below, the value of lastNum is 9:
numbers <- c(16, 20, 3, 5, 9)
lastNum <- tail(numbers, 1)    # explain what this does

Write R expressions:

1) To check whether lastNum is less than 6 or greater than 10

2) To check whether lastNum is in the interval [10, 20). (By the rules of mathematical notation this means 10 is included but 20 is not).

3) To output TRUE if the following operation gives 2:

  • take lastNum
  • divide it by 7
  • subtract the integer part and the first digit after the decimal point (hint: multiply by 10, then integer division by 1 gives you ... what)
  • multiply by 100
  • integer divide by 1
  • take the third root

(Hints: use lots of parentheses and compare the final result to 2. To debug, select parts of the code and execute separately. If the console gets stuck because it is expecting a closing parenthesis, and all you see is the "+" sign, simply press <escape> to abort evaluation.)

Check your answers (but don't cheat) ... 

1) lastNum < 6 | lastNum > 10
2) lastNum >= 10 & lastNum < 20
3) ((((9/7) - ((((9/7) * 10) %/% 1 )/10)) * 100) %/% 1 )^(1/3) == 2


 

Variables

In order to store the results of expressions and computations, you can freely assign them to variables[1]. Variables are created by R whenever you first use them (i.e. space in memory is allocated to the variable and a value is stored in that space.) Variable names distinguish between upper case and lower case letters. There are a small number of reserved names that you are not allowed to redefine, and R syntax contains very small number of predefined constants, such as pi. However these constants can be overwritten - be careful: R will allow you to define pi <- 3 but casually redefining the foundations of mathematics may lead to unintended consequences. Read more about variable names at: 

?make.names
?reserved

To assign a value to a constant, use the assignment operator <-. This is the default way of assigning values in R. You could also use the = sign, but there are subtle differences. (See: ?"<-"). There is a variant of the assignment operator <<- which is sometimes used inside functions. It assigns to a global context. This is possible, but not preferred since it generates a side effect of a function. Don't do this. Forget about <<- again. 

a <- 5
a
a + 3
b <- 8
b
a + b
a == b # not assignment: equality test
a != b # not equal
a < b  # less than

Note that all of R's data types (as well as functions and other objects) can be assigned to variables.

There are very few syntactic restrictions on variable names (discussed eg. here) but this does not mean esoteric names are good. For the sake of your sanity, use names that express the meaning of the variable, and that are unique. Many R developers use dotted.variable.names, some people use the pothole_style, my personal preference is to write camelCaseNames. And while the single letters c f n s Q are syntactically valid variable names, they coincide with commands for the debugger browser and will execute debugger commands, rather than displaying variable values when you are debugging. Finally, try not to use variable names that are the same as parameter names in functions. Alas, you see this often in code, but such code can be hard to read because the semantics of the actual argument versus the parameter name becomes obscured. It's just common sense really: don't call different things by the same name. 

# I don't like...
col <- c("red", "grey")
hist(rnorm(200), col=col)

# I prefer instead something like...
rgStripes <- c("red", "grey")
hist(rnorm(200), col=rgStripes)


 



 


Further reading, links and resources

 


Notes

  1. ↑ We call these "variables" because of what function they perform in our code, the actually are R "objects".


 


Self-evaluation

 



 



 

If in doubt, ask! If anything about this learning unit is not clear to you, do not proceed blindly but ask for clarification. Post your question on the course mailing list: others are likely to have similar problems. Or send an email to your instructor.


 

About ...
 
Author:

Boris Steipe <boris.steipe@utoronto.ca>

Created:

2017-08-05

Modified:

2017-09-10

Version:

1.0

Version history:

  • 1.0 Completed to first live version
  • 0.1 Material collected from previous tutorial

CreativeCommonsBy.png This copyrighted material is licensed under a Creative Commons Attribution 4.0 International License. Follow the link to learn more.

Retrieved from "http://steipe.biochemistry.utoronto.ca/abc/index.php?title=RPR-Syntax_basics&oldid=9939"