that we use it to illustrate the examples in this book. Throughout the book, you
find some tips and tricks on how things can be done in RStudio. If you decide to use
a different code editor, you can still use all the code examples and you’ll get
identical results.
To open RStudio, click the RStudio icon in your menu system or on your
desktop, as shown in Figure 2-4. (You can find installation instructions in this book’s
appendix.)
Figure 2-4: Opening RStudio.
Once RStudio started, choose File⇒New⇒R Script.
Your screen should look like Figure 2-5. You have four work areas:
Source: The top-left corner of the screen contains a text editor that lets you
work with source script files. Here, you can enter multiple lines of code, save
your script file to disk, and perform other tasks on your script. This code editor
works a bit like every other text editor you’ve ever seen, but it’s smart. It
recognizes and highlights various elements of your code, for example (using
different colors for different elements), and it also helps you find matching
brackets in your scripts.
Pdf find highlighted text - search text inside PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn how to search text in PDF document and obtain text content and location information
find and replace text in pdf file; how to make a pdf file text searchable
Pdf find highlighted text - VB.NET PDF Text Search Library: search text inside PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn How to Search Text in PDF Document and Obtain Text Content and Location Information in VB.NET application
find and replace text in pdf; pdf text search tool
Console: In the bottom-left corner, you find the console. The console in RStudio
is identical to the console in RGui (refer to “Seeing the naked R console,” earlier
in this chapter). This is where you do all the interactive work with R.
Workspace and history: The top-right corner is a handy overview of your
workspace, where you can inspect the variables you created in your session, as
well as their values. (We discuss the workspace in more detail later in this
chapter.) This is also the area where you can see a history of the commands
you’ve issued in R.
Files, plots, package, and help: In the bottom-right corner, you have access
to several tools:
• Files: This is where you can browse the folders and files on your computer.
• Plots: This is where R displays your plots (charts or graphs). We discuss plots in
Part V.
• Packages: This is where you can view a list of all the installed packages. A
package is self-contained set of code that adds functionality to R, similar to the
way that an add-in adds functionality to Microsoft Excel.
• Help: This is where you can browse the built-in Help system of R.
Figure 2-5: RStudio’s four work areas.
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
to search text-based documents, like PDF, Microsoft Office search in the viewed document and find what you for, all results will be highlighted with specific
text select tool pdf; search multiple pdf files for text
Starting Your First R Session
If you’re anything like the two of us, you’re probably just itching to get hold of
some real code. In this section, you get to do exactly that. Get ready to get your
hands dirty!
Saying hello to the world
Programming books typically start with a very simple program. Often, the
objective of this first program is to create the message 
“Hello world!”
In R, this
program consists of one line of code.
Start a new R session, type the following in your console, and press Enter:
> print(“Hello world!”)
R responds immediately with this output:
[1] “Hello world!”
Congratulations! You’ve just completed your first R script.
As we explain in the introduction to this book, we collapse these two things
into a single block of code, like this:
> print(“Hello world!”)
[1] “Hello world!”
Doing simple math
Type the following in your console to calculate the sum of five numbers:
> 1+2+3+4+5
[1] 15
The answer is 
15
, which you can easily verify for yourself. You may think that
there’s an easier way to calculate this value, though — and you’d be right. We
explain how in the following section.
Using vectors
A vector is the simplest type of data structure in R. The R manual defines a
vector as “a single entity consisting of a collection of things.” A collection of
numbers, for example, is a numeric vector — the first five integer numbers form a
numeric vector of length 5.
To construct a vector, type the following in the console:
> c(1,2,3,4,5)
[1] 1 2 3 4 5
In constructing your vector, you have successfully used a function in R. In
programming language, a function is a piece of code that takes some inputs and
does something specific with them. In constructing a vector, you tell the 
c()
function to construct a vector with the first five integers. The entries inside the
parentheses are referred to as arguments.
You also can construct a vector by using operators. An operator is a symbol
you stick between two values to make a calculation. The symbols 
+
-
*
, and 
/
are
all operators, and they have the same meaning they do in mathematics. Thus, 
1+2
in R returns the value 
3
, just as you’d expect.
One very handy operator is called sequence, and it looks like a colon (
:
). Type
the following in your console:
> 1:5
[1] 1 2 3 4 5
That’s more like it. With three keystrokes, you’ve generated a vector with the
values 
1
through 
5
. Type the following in your console to calculate the sum of this
vector:
> sum(1:5)
[1] 15
Storing and calculating values
Using R as a calculator is very interesting but perhaps not all that useful. A
much more useful capability is storing values and then doing calculations on these
stored values.
Try the following:
> x <- 1:5
> x
[1] 1 2 3 4 5
In these two lines of code, you first assign the sequence 
1:5
to a variable
called 
x
. Then you ask R to print the value of 
x
by typing x in the console and
pressing Enter.
In R, the assignment operator is 
<-
, which you type in the console by using
two keystrokes: the less-than symbol (
<
) followed by a hyphen (
-
). The
combination of these two symbols represents assignment.
In addition to retrieving the value of a variable, you can do calculations on
that value. Create a second variable called 
y
, and assign it the value 
10
. Then add
the values of 
x
and 
y
, as follows:
> y <- 10
> x + y
[1] 11 12 13 14 15
The values of the two variables themselves don’t change unless you assign a
new value. You can check this by typing the following:
> x
[1] 1 2 3 4 5
> y
[1] 10
Now create a new variable 
z
, assign it the value of 
x+y
, and print its value:
> z <- x + y
> z
[1] 11 12 13 14 15
Variables also can take on text values. You can assign the value 
“Hello”
to a
variable called 
h
, for example, by presenting the text to R inside quotation marks,
like this:
> h <- “Hello”
> h
[1] “Hello”
You must present text or character values to R inside quotation marks —
either single or double. R accepts both. So both 
h <- “Hello”
and 
h <-
‘Hello’
are examples of valid R syntax.
In “Using vectors,” earlier in this chapter, you use the 
c()
function to combine
numeric values into vectors. This technique also works for text. Try it:
> hw <- c(“Hello”, “world!”)
> hw
[1] “Hello” “world!”
You can use the 
paste()
function to concatenate multiple text elements. By
default, 
paste()
puts a space between the different elements, like this:
> paste(“Hello”, “world!”)
[1] “Hello world!”
Talking back to the user
You can write R scripts that have some interaction with a user. To ask the user
questions, you can use the 
readline()
function. In the following code snippet, you
read a value from the keyboard and assign it to the variable 
yourname
:
> h <- “Hello”
> yourname <- readline(“What is your name?”)
What is your name?Andrie
> paste(h, yourname)
[1] “Hello Andrie”
This code seems to be a bit cumbersome, however. Clearly, it would be much
better to send these three lines of code simultaneously to R and get them
evaluated in one go. In the next section, we show you how.
Sourcing a Script
Until now, you’ve worked directly in the R console and issued individual
commands in an interactive style of coding. In other words, you issue a command,
R responds, you issue the next command, R responds, and so on.
In this section, you kick it up a notch and tell R to perform several commands
one after the other without waiting for additional instructions. Because the R
function to run an entire script is 
source()
, R users refer to this process as sourcing
a script.
To prepare your script to be sourced, you first write the entire script in an
editor window. In RStudio, for example, the editor window is in the top-left corner
of the screen (refer to Figure 2-5). Whenever you press Enter in the editor window,
the cursor moves to the next line, as in any text editor.
Type the following lines of code in the editor window. (Remember that in
RStudio the source editor is in the top-left corner, by default.) Notice that the last
line contains a small addition to the code you saw earlier: the 
print()
function.
h <- “Hello”
yourname <- readline(“What is your name?”)
print(paste(h, yourname))
Remember to type the 
print()
function as part of your script. Sourced
scripts behave differently from interactive code in printing results. In
interactive mode, a result is printed even without a 
print()
function. But when
you source a script, output is printed only if you have an explicit 
print()
function.
You can type multiple lines of code into the source editor without having each
line evaluated by R. Then, when you’re ready, you can send the instructions to R —
in other words, source the script.
When you use RGui or RStudio, you can do this in one of three ways:
Send an individual line of code from the editor to the console. Click the
line of code you want to run, and then press Ctrl+R in RGui. In RStudio, you can
press Ctrl+Enter or click the Run button.
Send a block of highlighted code to the console. Select the block of code
you want to run, and then press Ctrl+R (in RGui) or Ctrl+Enter (in RStudio).
Send the entire script to the console (which is called sourcing a script).
In RGui, click anywhere in your script window, and then choose Edit⇒Run all. In
RStudio, click anywhere in the source editor, and press Ctrl+Shift+Enter or click
the Source button.
These keyboard shortcuts are defined only in RStudio. If you use a different
source editor, you may not have the same options.
Now you can send the entire script to the R console. To do this, click the
Source button in the top-right corner of the editor window or choose Edit⇒Source.
The script starts, reaches the point where it asks for input, and then waits for you
to enter your name in the console window. Your screen should now look like Figure
2-6. Notice that the Workspace window now lists the two objects you created: 
h
and 
yourname
.
Figure 2-6: Sending a script to the console in RStudio.
When you click the Source button, 
source(‘~/.active-rstudio- document’)
appears in the console. What RStudio actually does here is save your script in
a temporary file and then use the R function 
source()
to call that script in the
console. Remember this function; you’ll meet it again.
Finding help on functions
We discuss R’s built-in help system in Chapter 11, but for now, to get help on
any function, type ? in the console. To get help with the 
save()
function, for
example, type the following:
> ?paste
This code opens a Help window. In RStudio, this Help window is in the
bottom-right corner of your screen by default. In other editors, the Help
window sometimes appears as a local web page in your default web
browser.
You also can type help, but remember to use parentheses around your
search term, like so:
> help(paste)
Navigating the Workspace
So far in this chapter, you’ve created several variables. These form part of
what R calls the workspace, which we explore in this section. The workspace refers
to all the variables and functions (collectively called objects) that you create during
the session, as well as any packages that are loaded.
Often, you want to remind yourself of all the variables you’ve created in the
workspace. To do this, use the 
ls()
function to list the objects in the workspace. In
the console, type the following:
> ls()
[1] “h”        “hw”       “x”        “y”        “yourname” “z”
R tells you the names of all the variables that you created.
One very nice feature of RStudio lets you examine the contents of the
workspace at any time without typing any R commands. By default, the top-
right window in RStudio has two tabs: Workspace and History. Click the
Workspace tab to see the variables in your workspace, as well as their values.
(refer to Figure 2-5).
Manipulating the content of the workspace
If you decide that you don’t need some variables anymore, you can remove
them. Suppose that the object 
z
is simply the sum of two other variables and no
longer needed. To remove it permanently, use the 
rm()
function and then use the
ls()
function to display the contents of the workspace, as follows:
> rm(z)
> ls()
[1] “h”        “hw”       “x”        “y”        “yourname”
Notice that the object 
z
is no longer there.
Saving your work
You have several options for saving your work:
You can save individual variables with the 
save()
function.
You can save the entire workspace with the 
save.image()
function.
You can save your R script file, using the appropriate save menu command in
your code editor.
Suppose you want to save the value of 
yourname
. To do that, follow these
steps:
1. Find out which working directory R will use to save your file by
typing the following:
> getwd()
[1] “c:/users/andrie”
The default working directory should be your user folder. The exact name and
path of this folder depend on your operating system. (In Chapter 12, you get more
familiar with the working directory.)
If you use the Windows operating system, the path is displayed with
slashes instead of backslashes. In R, similar to many other programming
Documents you may be interested
Documents you may be interested