My R Tutorial

A bunch of tutorials try to handhold you too much, or only try to get a basic version some program working without underlying details. This tutorial was written with two people in mind and will give give them (and probably you too!) the most bang for the buck. By the end of it, we'll use R to solve nonlinear and differential equations.

Step one is to install the R interpreter for your platform from the official site. Then either add this binary to your path, or install an environment like Rstudio to run commands.

--IMPORTANT--
As You Go Through The Tutorial, Run Commands in The Prompt and Look at The Results!

Types

While numbers aren't the only fundamental type in R, we can pretty much get away with ignoring everything else. All "numbers" in R can be stored in several constructs.

The first and most fundamental are vectors, which act as homogeneous data types that you index through with square brackets.

We make the vector with the "c" function. Functions that create objects are called constructors and we'll refer to them as such throughout the section.

Lists can be indexed the same way, but can hold virtually any value. We construct them with the "list" function.

Matrices are like vectors, but in strictly two dimensions (I guess you'd call R matrices "2d" matrices). They have a lot of built-in functions and constructors.

You can find a list of the most common matrix-related functions here.

Finally, arrays are probably the most general and useful type, because they act as a matrix, but in any number of dimensions.

Remember, these types are made with functions, so you can type help(<constructor_name>) to find more information about ways to make those types.

Operations on Those Types

You know intuitively what a "for loop" or "while loop" looks like, and you can use those to do indexing operations, but R has taken some functional programming elements from lisp to let you apply a function to each element of its input.

That is, you can define a function and just pass any of these objects to it, and R and it will attempt to apply this function to every element of its input, returning a new matrix/vector of the outputs.

Of course, this fails on non-numeric input

Graphing

This is what you want. This is the cash money funding power.

The most basic graphs are produced by built-in functions like plot(), which provide several types of representation for input.

You can give plot just a vector of values, and the x positions will be inferred from the indices.

    plot(7:1, type="l")

Or you can specify both.

    plot(1:6, c(8,1,6,3,5,4), type="s", lwd=3, col="blue")

Moreover, there are more general options you can pass to all graphing methods, similar to "col=<value>", again, you should read documentation to figure it out when necessary.

When you create a graph, you also create a canvas on which you can add additional lines, a legend, points, etc... There are many graph-related functions to look at, so take a look at help(point), help(lines) and help(par) and play around with the inputs and options!

If you want more fancy graphs, then you should install and learn ggplot2

Libraries

Importing Libraries

Now it's time for you to spring out on your own and develop your own libraries. To install a package, you run the command
    install.packages("packagename")

once its installed, you import its functions into the current R session with

    library(packagename)

note that you need quotations around the install command, whereas you don't need them in the "library" import command.

ggplot2

So, we want to have slightly prettier graphs. We can accomplish this with ggplot2. Install and import the package "ggplot2" the way we just went over.

Once imported, ggplot2 provides two methods for plotting: qplot and ggplot.

qplot, aka "quickplot", provides an interface similar to the default "plot" command for outputting information on a graph. The formatting, however, is slightly different. Here are some example commands.

    qplot(1:10, rnorm(10), colour = runif(10))

makes

and

   qplot(mpg, wt, data = mtcars, colour = cyl, geom="path")

which takes advantage of the build in mtcars and mpg datasets makes

 


Now, the defaults that qplot provides already looks a bit nicer than the vanilla plot, however the main tool of "ggplot2" is the ggplot function.
The ggplot() function is more complicated and intricate, but is required to fully customize a graph.

We define our data set in a data frame (dont worry about it for now) and define points on the graph with geom_point functions. Our output is such:

Save this library for when you need it, don't sweat the details about fancy graphs, and as always, read the library documentation to get more info!

Animated Graphs

We can install another package to create animated graphs, called "animation". However, it relies on "imagemagick" binaries to be present on your computers path. The easiest way to install is via the graphicsmagick installer. Note that you need to restart your computer after running the installer to update your path. You will also need to add  convert="gm convert" as a parameter because that's how you run graphicsmagick's convert operation.

Here's a standard example where we use standard R functions to plot a bunch of graphs in memory, which then gets compiled into one animated graphs.

"curve" is like plot, but instead of points, it takes a function and tries to graph it smoothly. we draw two curves on a canvas 100 times (and their legend) to get the following:

Note that it saves to whatever directory you're working in by default.

We can take things to three dimensions, to visualize a moving $z=sin(x \cdot y$

this code generates

If you want to know more, as always, use the "help" command!

Solving Nonlinear Equations

Alright, now we're in core material-land. There are two main methods you'd want to solve equations. The first is "optimize" which is a general-purpose optimization function that's built into R. If you can phrase your equation into an optimization problem, then it's pretty straightforward to use. Let's look at a parabola as an example:

the optimization operations give us the following output

For general multi-dimensional optimization, you should consder using the "optim" function. Let's try applying it to our original parabola example.

this gets us:

a very close approximation of 0!

But I said multi-dimensional function. Well, for a 2d (and more dimensions) function would be optimized like this.

which gives us similar results

It's worth noting that for optim (but not optimize), you can use Inf and -Inf for your bounds.

Of course, these are optimization functions. For finding roots, you might consider using nleqslv, which you install from the package "nleqslv", which provides a function of the same name, used in a similar fashion. You specify at the minimum a starting point and a function. You can also specify an approximation method.

Consider looking at help(optimize), help(optim), help(nleqslv)

Solving Differential Equations

Differential equations, as we represent them, look like this.

We will only look at an ordinary differential equation, and a differential delay equation, but they are both solved with the deSolve library.

This is mainly a question of notation. How would we solve a rigid ODE problem notated as such?
$$y'_1 = \frac{I_2 - I_3}{I_1} y_2 y_3 \\
y'_2 = \frac{I_3 - I_1}{I_2} y_1 y_3 \\
y'_3 =\frac{I_1 - I_2}{I_3} y_1 y_2 $$

The R version looks like this. Where each index of the input y vector is a different dimension/coordinate of our system.

You'll notice, all we really need to do is define some initial parameters to give the ode function, and we get a matrix describing our function. Note that we selected the very accurate Runge-Kutta method. For more methods to choose from, just run help(ode)*!        *do it

Delay equations have a delay term, which our library represents as the function lagvalue. Otherwise, dde's are similar to ode's except that you solve them with the "dede" function.

$$y' = -y(t-1),\\
y(t) = 1, \ \ \ \ \text{for}\ \ \ \  t \in \lbrack-1,0\rbrack$$

The R representation of this system is as such:

Again, we give an initial y and an initial sequence. If our function had additional parameters, we'd specify them in the "params=" section.
And bam! Look at our output graph!

Well, this is the last time I'll say it here, but please, just when in doubt, try using the help() function.

Making Libraries

You may develop something of your own that you want others to use. It's really easy, not even worth mentioning really, aside from trying to create a sense of obligation out of the reader. Just skim this good guide for a second to remember that you can make your own packages.

Conclusion

There we go. We didn't go over "what is a loop" or "how to program", but how to get the raw testosterone-laden approximations you crave. Now go, take this knowledge and investigate further into R, the libraries, the types and the built-ins that help you get stuff done in new and fun ways.