`{mosaicCalc}`

Quick
Reference`{mosaicCalc}`

First, install R and RStudio according to the instructions given by your instructor. Opening R or RStudio will present you with an “R console.”

Then, you need to install the `{mosaicCalc}`

software and
a lot of related software. Do this from your R console:

`install.packages("mosaic", "ggformula", "mosaicCalc")`

This will take some minutes, but the process is entirely automatic.

You only need to install the packages once. If you switch to another computer, however, you may need to install the packages on that computer.When you sit down to work with `{mosaicCalc}`

, you need to
have an “R session” started. This is typically accomplished by clicking
on the RStudio icon:

Alternatively, you may still have an R session open from your previous activities.

Before you can use `{mosaicCalc}`

, you need to tell R to
access the software. This is done with

`library(mosaicCalc)`

If you fail to do this, when you start using
`{mosaicCalc}`

functions you will encounter an error message
in this format

`Error in makeFun() : could not find function "makeFun"`

To fix this, go back and run the `library(mosaicCalc)`

command again.
`x <- 2`

*What it does*Stores the value 2 under the name`x`

*Vocabulary*- This is an
*assignment statement* `<-`

is the*assignment operator*- Overall, the effect of the command is to
*assign a name to the value 2*

- This is an
*Notes*- You make the left-pointing arrow by using the “less than” sign followed by a hyphen.
- Your commands will be more readable if you put a space on either
side of
`<-`

. But never put a space between the two characters in the arrow. `2 <- x`

might make sense to a human, but in R it will lead to an error message, “invalid(do_set) left-hand side to assignment.”- An assignment statement does not have any printed output, so there will be no indication of having done anything, other than the absence of error messages.

`x`

(or any other name)*What it does*Provides the value previous stored under that name*Vocabulary*are assigned to*Names*.*objects**Notes*- A name can be used as a complete command, with the result of printing to the screen the object stored under that name.
- Valid names cannot contain spaces, or any punctuation character
except
`.`

and`_`

- Valid names cannot start with a numeral.

`sqrt(3)`

*What it does*The first example calculates \(\sqrt{3}\).*Vocabulary*`sqrt`

is the name of a*function*- 3 is the input to the function
`sin`

. Another word for input is.*argument* - The parentheses surrounding the argument come after the function
name.
`sin(3)`

causes the sine calculation to be carried out.

*Notes*- Spaces are allowed just about anywhere, but not in the middle of a name.
- If you capitalize one of the functions, you get an error message such as “could not find function "Sin".”
- Later, you will write statements like
`sqrt(x)`

. For this to work,`x`

must have been previously assigned to a value. If there is no such assignment, you’ll get an error code such as “object "x" not found.”

`(3 + 7 * sin(2*pi*x)) / (x^2 - 4)`

*What it does*Expresses a formula which would traditionally be written \[\frac{3 + 7\,\sin(2 \pi x)}{x^2 - 4}\]*Vocabulary*- The outer parentheses in
`(3 + 7 * sin(2*pi*x))`

are. Grouping parentheses do what you would expect: govern the order of the operations.*grouping parentheses* - The parentheses following
`sin`

in`sin(2*pi*x)`

are. These signal to R that you want to evaluate the function on the input contained inside the parentheses.*function evaluation parentheses*

- The outer parentheses in
*Notes*- You can always identify function evaluation parentheses, since they will be immediately preceeded by the name of a function. Grouping parentheses are not preceeded by a function name.
- You will use grouping parentheses more often in R than in traditional notation, because there is no use of superscripts or \(\div\) in R. All commands are a line of typewriter characters.
- Multiplication must be made explicit, using the
`*`

character. - Exponentiation is signified with the
`^`

character, as in`x^2`

- Giving the above as a stand-alone calculator-style command will
fail, unless you have previously assigned values to each of the names
(e.g.
`x`

) used in the formula. Typically you will write formulas in. (See below.)*tilde expressions*

A ** tilde expression** is a special feature of
R that let’s you write down a mathematical expression without having the
expression evaluated. We use tilde expressions to construct our own
mathematical functions and for a handful of other, related purposes such
as plotting.

`y^2 + 3*y ~ y`

*What it does*A tilde expression doescause any computation to be done. It is simply a way of writing down a mathematical relationship for use later on.*not**Vocabulary*- The
is a character little used in English. It looks like ~. Most US keyboards place it in the upper-left key.*tilde* - There are two R expressions involved, one on the
of the tilde, the other on the … need we say it? …*left-hand side*. In the example,*right-hand side*`y^2 + 3*y`

is the left-hand side and plain, ordinary`y`

is on the right-hand side. - In R/mosaic, The translation of tilde into English is any of the following: “[left] is a function of [right]”, or “[left] versus [right]” or “[left] depends on [right]”.

- The
*Notes*- You will always use a tilde expression as an
. It is merely a description of how the two sides are related and doesn’t by itself cause any computation to be done. As such, you will never use it as a stand-alone command.*argument to a function* - Many of the tilde expressions we use in
*MOSAIC Calculus*will have more than one name in the right-hand side expression. The multiple names are separated by`+`

or`&`

(either will do). The`+`

does not mean “add them,” it’s merely a way of saying “and.” For instance, the right-hand side in `3*x*exp(y) ~ x + y”

- You will always use a tilde expression as an

`g <- makeFun(2 + 3*x - 7*x^2 ~ .)`

*What it does*Creates an R function named`g`

corresponding to \(g(x)\equiv 2 + 3x - 7\,x^2\)*Vocabulary*`makeFun()`

is a*function constructor*- The argument to
`makeFun()`

is a*tilde expression*

*Notes*- A tilde expression is always centered on the special character named “tilde”: ~. Tilde expressions have a right side and a left side.
- For
`makeFun()`

the right side should be a simple period (`.`

) - Like all names,
`makeFun()`

is. So using*case sensitive*`makefun`

(note: lower-case`f`

in`fun`

) won’t work. - If you use just the name of your function as a command, that is,
`g`

, you will get the output

The first line tells you that you defined g as a function of x. The second line tells the formula for it. The third line is relevant only to advanced R programmers; you can ignore it.`#> function (x) #> 2 + 3 * x - 7 * x^2 #> <environment: 0x7fb82533e3c8>`

`slice_plot(exp(x) ~ x, bounds(x = -3 : 3))`

*What it does*Draws a graph of the function \(e^x\) with the horizontal axis running from \(-3 \leq x \leq 3\).*Vocabulary*- The first argument is a
. This is a general pattern in*tilde expression*`{mosaicCalc}`

commands. - The second argument specifies the
to use in the graph, that is, the extent of the horizontal axis. This will*bounds***always**be in the form shown above: applying the`bounds()`

function to a.*named argument* - A named argument consists of two parts: a name and an R expression.
In the example, the name is
`x`

and the R expression is \(-3 : 3\). That R expression means “from -3 to 3.” The colon (`:`

) is essential punctuation; it’s what separates grammatically the lower end of the bounds from the upper end. (For experienced R users: If you prefer to use the form`c(-3,3)`

instead of the colon, that works. For specialized R programmers: The ordinary integer orientation of`:`

is suspended within`bounds()`

so the limits you give will be treated exactly.) - The plotting function is called
`slice_plot()`

because we think of a function of one input as a slice of a multivariable surface, but we won’t get into that immediately.

- The first argument is a
*Notes*- Used as shown above, there will be
**three consecutive closing parentheses**at the end of the command. - The argument to
`bounds()`

will always be named. That name should match the one on the right-hand side of the tilde expression. - You will always use
`:`

to collect together the lower and upper bounds of the graphics frame. To graph the function from 0 to 10, you would replace the`-3:3`

with`0:10`

. - The extent of the vertical axis, that is, the
, is determined automatically.*range*

- Used as shown above, there will be
*Useful additional arguments*- You can draw the function in a color by adding an additional
argument, e.g.
`color="blue"`

. To see the full list of named colors in R, give the command`colors()`

in a sandbox. (You need the empty parentheses, otherwise you’ll be shown the software underlying the list of colors.) Notice that the color should always be in quotes, e.g.`"green"`

or`"darkorchid"`

. - You can draw a thicker curve with the
`size`

argument, for instance`size=2`

. - If you want the curve to be semi-transparent, for instance so that
you can see another curve underneath, use the argument
`alpha = 0.2`

. The alpha value can range from 0.0 (completely invisible) to 1.0 (completely opaque).

- You can draw the function in a color by adding an additional
argument, e.g.
*Common mistakes*- If you type
`slice_plot(exp(x)~x, bounds(-3:3)))`

(leaving out the name`x`

inside`bounds()`

), you get an error of, “Bounds involves 0 variables, but function has 1” - If you type
`slice_plot(exp(x)~x, bounds(t=-3:3))`

(mismatching names in tilde expression and bounds), you get an error of, “Bounds has variable(s) t but function has argument(s) named x” - If you type
`slice_plot(exp(x), bounds(x=-3:3))`

(forgetting the`~x`

in the tilde expression), you get an error of, “object ‘x’ not found” - If you type
`slice_plot(exp(x)~x)`

, you get an error of, “bounds must be specified when there is no preceeding layer.” Aside from the misspelling of preceding, this is telling the user that there wasn’t a previous graph to pull the bounds from, so you need to specify the bounds as an argument to`slice_plot()`

. - If you leave out a closing parenthesis, you will get the admittedly
cryptic error of, “Error in parse(text = x, keep.source = TRUE) :
:4:0: unexpected end of input 2:…”

- If you type

In *MOSAIC Calculus*, we generally use a contour-plot format
to display graphically a function with two inputs. This is done in much
the same way as `slice_plot()`

.

`contour_plot(3 + 2*x - 4*y + 0.5*x*y ~ x & y, bounds(x=-5:5, y=0:10))`

*What it does*Draws a contour plot in a graphics frame with two dimensions.*Vocabulary*Nothing here that you haven’t seen in`slice_plot()`

: tilde expression, bounds, …*Notes*- The tilde expression names two inputs on the right-hand side. Those
names should match the ones in the left-hand side and in the arguments
to
`bounds()`

. - The right-hand side of the tilde can be written either with
`+`

or`&`

. Both have the same effect. - There are
**two arguments**to`bounds()`

, one for each of the two inputs to the function being plotted. - The input represented on the horizontal axis is determined by the
first name in the arguments to
`bounds()`

. The vertical axis is set by the second name. - The extent of the bounds for one input doesn’t need to match the extent for the other input.

- The tilde expression names two inputs on the right-hand side. Those
names should match the ones in the left-hand side and in the arguments
to
*Useful additional arguments*After the tilde expression and the`bounds()`

statement, you can add additional named arguments, separated as always by commas, to customize your graph.`skip = 0`

Label every one of the contours, rather than the default of skipping one between labels.`filled = FALSE`

Don’t color in the background. This is particularly useful when showing two or more graphical layers.`contour_color = "blue"`

(or any other color) Instead of using the function output level to determine the color of each contour, use just one color for all. This is useful when, for example, you want to show just the zero contour of each of two functions.

When you use `makeFun()`

to define a function of two
inputs, the created function will take two arguments, one for each of
the inputs. Those arguments are named and it is a good idea when
evaluating the function you created using the names explicitly.

`<- makeFun(x + 15*y - x*y ~ .) h `

`h(y=3, x=2)`

*What it does*Evaluates the function \(h()\) with the \(x\) input set to 2 and the \(y\) input set to 3.*Vocabulary*let you direct a value to a specific input.*Named inputs*

*Notes*- The way we defined the example function
`h()`

, the first argument will be`x`

and the second`y`

. So you could perform the same evaluation as in the above command with`h(2, 3)`

. But it’s easy to forget or mistake the order of the arguments. Using the named-argument style makes it clearer which value is intended for which argument. - You may notice commands like
`slice_plot(h(x=x, y=3) ~ x, bounds(x=-1:1))`

. At first glance, this may look silly. What it means is that the \(x\) argument to \(h()\) will take on the set of values inside the bounds, which is itself written in terms of \(x\).

- The way we defined the example function

Sometimes you may want to compare two or more functions in the same
graphics frame. You do this by drawing the individual functions in the
usual way, but connecting the commands with a
** pipe**, signified by the token

`%>%`

`slice_plot(x^2 ~ x, bounds(x=-2:2)) %>% slice_plot(sin(x) ~ x, color="blue")`

*What it does*Overlays one graphics layer on another.*Vocabulary*- The
`%>%`

symbol is pronounced “”*pipe* - A command involving a pipe is called a
. Think of the calculation as flowing from one command to the next, left to right.*pipeline*

- The
*Notes*- If you have specified the
`bounds()`

at an early stage in the pipeline, you don’t need to specify it again in the later plotting commands. But, if you want, feel free to set the bounds explicitly. This is helpful if you want the graphics bounds to be different for the different layers. - It’s a good idea to write a pipeline with one line for each stage,
with the pipe symbol at the
**end**of each stage. Like this:

`slice_plot(x^2 ~ x, bounds(x=-2:2)) %>% slice_plot(sin(x) ~ x, color="blue")`

- You can add as many stages as you like to the pipeline. Each stage
will add a new graphics layer. But remember that the last stage
**should not**be followed by the pipe symbol.

- If you have specified the

Essentially all of the data we use in this course is arranged as
** data frames**. (This is also true in statistics
and data science generally.) A data frame is a rectangular array. Each
column is called a

- Look at them to orient yourself or browse.
- Access a variable.
**Wrangle**them, for example extracting a subset of cases or combining data from two different data frames. Data wrangling is an important skill, but it isn’t the topic of this course. So when you need to wrangle data, we’ll tell you how.

For this course, almost all data will be provided by giving you the
name of dataframes. Sometimes this name will be simple and in the usual
form, e.g. `EbolaAll`

. Other time, the name will be preceded
with information about where the computer should look for the data,
e.g. `palmerpenguins::penguins`

.

Some simple, helpful commands for orienting yourself to a data frame:
- `names(EbolaAll)`

tells you the names of the columns in the
data frame. - `head(EbolaAll)`

shows the first several rows.
- `DT::datatable(EbolaAll)`

will show the entire data frame
interactively, allowing you to page through the data. -
`help(EbolaAll)`

displays documentation about the data
frame.

Once you know the basic facts of a data frame—what the variable names
are and what kind of thing each variable records—you are ready to use
the data in your work. Two common tasks are (1) to plot one variable
versus another and (2) to use the variables in some calculation, such as
fitting a model. Both tasks use much the same syntax based on
** tilde expressions**.

For instance:

- to plot the number of Ebola cases in Guinea versus date:
`gf_point(Gcases ~ Date, data = EbolaAll)`

. (See the “plotting data” section of this document.) The variable names (`Gcases`

and`Date`

) are used in the tilde expression, while the name of the data frame is specified in other argument, the named argument`data=`

. - For model-fitting, see below.

There is one type of data graphic that we will be using in this
course: the ** point plot** (also known as a
“scatter plot”). There are, of course, many other kinds of statistical
graphics such as density plots, jittered plots, etc. which you will
learn about in a statistics course, but we will not use them here.

A point plot always involves two variables from a data frame. To
illustrate, consider the `palmerpenguins::penguins`

data
frame, where each case is a individual penguin.

`kable(penguins)`

species | island | bill_length_mm | bill_depth_mm | flipper_length_mm | body_mass_g | sex | year |
---|---|---|---|---|---|---|---|

Adelie | Torgersen | 39.1 | 18.7 | 181 | 3750 | male | 2007 |

Adelie | Torgersen | 39.5 | 17.4 | 186 | 3800 | female | 2007 |

Adelie | Torgersen | 40.3 | 18.0 | 195 | 3250 | female | 2007 |

Adelie | Torgersen | NA | NA | NA | NA | NA | 2007 |

Adelie | Torgersen | 36.7 | 19.3 | 193 | 3450 | female | 2007 |

Adelie | Torgersen | 39.3 | 20.6 | 190 | 3650 | male | 2007 |

Adelie | Torgersen | 38.9 | 17.8 | 181 | 3625 | female | 2007 |

Adelie | Torgersen | 39.2 | 19.6 | 195 | 4675 | male | 2007 |

Adelie | Torgersen | 34.1 | 18.1 | 193 | 3475 | NA | 2007 |

Adelie | Torgersen | 42.0 | 20.2 | 190 | 4250 | NA | 2007 |

Adelie | Torgersen | 37.8 | 17.1 | 186 | 3300 | NA | 2007 |

Adelie | Torgersen | 37.8 | 17.3 | 180 | 3700 | NA | 2007 |

Adelie | Torgersen | 41.1 | 17.6 | 182 | 3200 | female | 2007 |

Adelie | Torgersen | 38.6 | 21.2 | 191 | 3800 | male | 2007 |

Adelie | Torgersen | 34.6 | 21.1 | 198 | 4400 | male | 2007 |

Adelie | Torgersen | 36.6 | 17.8 | 185 | 3700 | female | 2007 |

Adelie | Torgersen | 38.7 | 19.0 | 195 | 3450 | female | 2007 |

Adelie | Torgersen | 42.5 | 20.7 | 197 | 4500 | male | 2007 |

Adelie | Torgersen | 34.4 | 18.4 | 184 | 3325 | female | 2007 |

Adelie | Torgersen | 46.0 | 21.5 | 194 | 4200 | male | 2007 |

Adelie | Biscoe | 37.8 | 18.3 | 174 | 3400 | female | 2007 |

Adelie | Biscoe | 37.7 | 18.7 | 180 | 3600 | male | 2007 |

Adelie | Biscoe | 35.9 | 19.2 | 189 | 3800 | female | 2007 |

Adelie | Biscoe | 38.2 | 18.1 | 185 | 3950 | male | 2007 |

Adelie | Biscoe | 38.8 | 17.2 | 180 | 3800 | male | 2007 |

Adelie | Biscoe | 35.3 | 18.9 | 187 | 3800 | female | 2007 |

Adelie | Biscoe | 40.6 | 18.6 | 183 | 3550 | male | 2007 |

Adelie | Biscoe | 40.5 | 17.9 | 187 | 3200 | female | 2007 |

Adelie | Biscoe | 37.9 | 18.6 | 172 | 3150 | female | 2007 |

Adelie | Biscoe | 40.5 | 18.9 | 180 | 3950 | male | 2007 |

Adelie | Dream | 39.5 | 16.7 | 178 | 3250 | female | 2007 |

Adelie | Dream | 37.2 | 18.1 | 178 | 3900 | male | 2007 |

Adelie | Dream | 39.5 | 17.8 | 188 | 3300 | female | 2007 |

Adelie | Dream | 40.9 | 18.9 | 184 | 3900 | male | 2007 |

Adelie | Dream | 36.4 | 17.0 | 195 | 3325 | female | 2007 |

Adelie | Dream | 39.2 | 21.1 | 196 | 4150 | male | 2007 |

Adelie | Dream | 38.8 | 20.0 | 190 | 3950 | male | 2007 |

Adelie | Dream | 42.2 | 18.5 | 180 | 3550 | female | 2007 |

Adelie | Dream | 37.6 | 19.3 | 181 | 3300 | female | 2007 |

Adelie | Dream | 39.8 | 19.1 | 184 | 4650 | male | 2007 |

Adelie | Dream | 36.5 | 18.0 | 182 | 3150 | female | 2007 |

Adelie | Dream | 40.8 | 18.4 | 195 | 3900 | male | 2007 |

Adelie | Dream | 36.0 | 18.5 | 186 | 3100 | female | 2007 |

Adelie | Dream | 44.1 | 19.7 | 196 | 4400 | male | 2007 |

Adelie | Dream | 37.0 | 16.9 | 185 | 3000 | female | 2007 |

Adelie | Dream | 39.6 | 18.8 | 190 | 4600 | male | 2007 |

Adelie | Dream | 41.1 | 19.0 | 182 | 3425 | male | 2007 |

Adelie | Dream | 37.5 | 18.9 | 179 | 2975 | NA | 2007 |

Adelie | Dream | 36.0 | 17.9 | 190 | 3450 | female | 2007 |

Adelie | Dream | 42.3 | 21.2 | 191 | 4150 | male | 2007 |

Adelie | Biscoe | 39.6 | 17.7 | 186 | 3500 | female | 2008 |

Adelie | Biscoe | 40.1 | 18.9 | 188 | 4300 | male | 2008 |

Adelie | Biscoe | 35.0 | 17.9 | 190 | 3450 | female | 2008 |

Adelie | Biscoe | 42.0 | 19.5 | 200 | 4050 | male | 2008 |

Adelie | Biscoe | 34.5 | 18.1 | 187 | 2900 | female | 2008 |

Adelie | Biscoe | 41.4 | 18.6 | 191 | 3700 | male | 2008 |

Adelie | Biscoe | 39.0 | 17.5 | 186 | 3550 | female | 2008 |

Adelie | Biscoe | 40.6 | 18.8 | 193 | 3800 | male | 2008 |

Adelie | Biscoe | 36.5 | 16.6 | 181 | 2850 | female | 2008 |

Adelie | Biscoe | 37.6 | 19.1 | 194 | 3750 | male | 2008 |

Adelie | Biscoe | 35.7 | 16.9 | 185 | 3150 | female | 2008 |

Adelie | Biscoe | 41.3 | 21.1 | 195 | 4400 | male | 2008 |

Adelie | Biscoe | 37.6 | 17.0 | 185 | 3600 | female | 2008 |

Adelie | Biscoe | 41.1 | 18.2 | 192 | 4050 | male | 2008 |

Adelie | Biscoe | 36.4 | 17.1 | 184 | 2850 | female | 2008 |

Adelie | Biscoe | 41.6 | 18.0 | 192 | 3950 | male | 2008 |

Adelie | Biscoe | 35.5 | 16.2 | 195 | 3350 | female | 2008 |

Adelie | Biscoe | 41.1 | 19.1 | 188 | 4100 | male | 2008 |

Adelie | Torgersen | 35.9 | 16.6 | 190 | 3050 | female | 2008 |

Adelie | Torgersen | 41.8 | 19.4 | 198 | 4450 | male | 2008 |

Adelie | Torgersen | 33.5 | 19.0 | 190 | 3600 | female | 2008 |

Adelie | Torgersen | 39.7 | 18.4 | 190 | 3900 | male | 2008 |

Adelie | Torgersen | 39.6 | 17.2 | 196 | 3550 | female | 2008 |

Adelie | Torgersen | 45.8 | 18.9 | 197 | 4150 | male | 2008 |

Adelie | Torgersen | 35.5 | 17.5 | 190 | 3700 | female | 2008 |

Adelie | Torgersen | 42.8 | 18.5 | 195 | 4250 | male | 2008 |

Adelie | Torgersen | 40.9 | 16.8 | 191 | 3700 | female | 2008 |

Adelie | Torgersen | 37.2 | 19.4 | 184 | 3900 | male | 2008 |

Adelie | Torgersen | 36.2 | 16.1 | 187 | 3550 | female | 2008 |

Adelie | Torgersen | 42.1 | 19.1 | 195 | 4000 | male | 2008 |

Adelie | Torgersen | 34.6 | 17.2 | 189 | 3200 | female | 2008 |

Adelie | Torgersen | 42.9 | 17.6 | 196 | 4700 | male | 2008 |

Adelie | Torgersen | 36.7 | 18.8 | 187 | 3800 | female | 2008 |

Adelie | Torgersen | 35.1 | 19.4 | 193 | 4200 | male | 2008 |

Adelie | Dream | 37.3 | 17.8 | 191 | 3350 | female | 2008 |

Adelie | Dream | 41.3 | 20.3 | 194 | 3550 | male | 2008 |

Adelie | Dream | 36.3 | 19.5 | 190 | 3800 | male | 2008 |

Adelie | Dream | 36.9 | 18.6 | 189 | 3500 | female | 2008 |

Adelie | Dream | 38.3 | 19.2 | 189 | 3950 | male | 2008 |

Adelie | Dream | 38.9 | 18.8 | 190 | 3600 | female | 2008 |

Adelie | Dream | 35.7 | 18.0 | 202 | 3550 | female | 2008 |

Adelie | Dream | 41.1 | 18.1 | 205 | 4300 | male | 2008 |

Adelie | Dream | 34.0 | 17.1 | 185 | 3400 | female | 2008 |

Adelie | Dream | 39.6 | 18.1 | 186 | 4450 | male | 2008 |

Adelie | Dream | 36.2 | 17.3 | 187 | 3300 | female | 2008 |

Adelie | Dream | 40.8 | 18.9 | 208 | 4300 | male | 2008 |

Adelie | Dream | 38.1 | 18.6 | 190 | 3700 | female | 2008 |

Adelie | Dream | 40.3 | 18.5 | 196 | 4350 | male | 2008 |

Adelie | Dream | 33.1 | 16.1 | 178 | 2900 | female | 2008 |

Adelie | Dream | 43.2 | 18.5 | 192 | 4100 | male | 2008 |

Adelie | Biscoe | 35.0 | 17.9 | 192 | 3725 | female | 2009 |

Adelie | Biscoe | 41.0 | 20.0 | 203 | 4725 | male | 2009 |

Adelie | Biscoe | 37.7 | 16.0 | 183 | 3075 | female | 2009 |

Adelie | Biscoe | 37.8 | 20.0 | 190 | 4250 | male | 2009 |

Adelie | Biscoe | 37.9 | 18.6 | 193 | 2925 | female | 2009 |

Adelie | Biscoe | 39.7 | 18.9 | 184 | 3550 | male | 2009 |

Adelie | Biscoe | 38.6 | 17.2 | 199 | 3750 | female | 2009 |

Adelie | Biscoe | 38.2 | 20.0 | 190 | 3900 | male | 2009 |

Adelie | Biscoe | 38.1 | 17.0 | 181 | 3175 | female | 2009 |

Adelie | Biscoe | 43.2 | 19.0 | 197 | 4775 | male | 2009 |

Adelie | Biscoe | 38.1 | 16.5 | 198 | 3825 | female | 2009 |

Adelie | Biscoe | 45.6 | 20.3 | 191 | 4600 | male | 2009 |

Adelie | Biscoe | 39.7 | 17.7 | 193 | 3200 | female | 2009 |

Adelie | Biscoe | 42.2 | 19.5 | 197 | 4275 | male | 2009 |

Adelie | Biscoe | 39.6 | 20.7 | 191 | 3900 | female | 2009 |

Adelie | Biscoe | 42.7 | 18.3 | 196 | 4075 | male | 2009 |

Adelie | Torgersen | 38.6 | 17.0 | 188 | 2900 | female | 2009 |

Adelie | Torgersen | 37.3 | 20.5 | 199 | 3775 | male | 2009 |

Adelie | Torgersen | 35.7 | 17.0 | 189 | 3350 | female | 2009 |

Adelie | Torgersen | 41.1 | 18.6 | 189 | 3325 | male | 2009 |

Adelie | Torgersen | 36.2 | 17.2 | 187 | 3150 | female | 2009 |

Adelie | Torgersen | 37.7 | 19.8 | 198 | 3500 | male | 2009 |

Adelie | Torgersen | 40.2 | 17.0 | 176 | 3450 | female | 2009 |

Adelie | Torgersen | 41.4 | 18.5 | 202 | 3875 | male | 2009 |

Adelie | Torgersen | 35.2 | 15.9 | 186 | 3050 | female | 2009 |

Adelie | Torgersen | 40.6 | 19.0 | 199 | 4000 | male | 2009 |

Adelie | Torgersen | 38.8 | 17.6 | 191 | 3275 | female | 2009 |

Adelie | Torgersen | 41.5 | 18.3 | 195 | 4300 | male | 2009 |

Adelie | Torgersen | 39.0 | 17.1 | 191 | 3050 | female | 2009 |

Adelie | Torgersen | 44.1 | 18.0 | 210 | 4000 | male | 2009 |

Adelie | Torgersen | 38.5 | 17.9 | 190 | 3325 | female | 2009 |

Adelie | Torgersen | 43.1 | 19.2 | 197 | 3500 | male | 2009 |

Adelie | Dream | 36.8 | 18.5 | 193 | 3500 | female | 2009 |

Adelie | Dream | 37.5 | 18.5 | 199 | 4475 | male | 2009 |

Adelie | Dream | 38.1 | 17.6 | 187 | 3425 | female | 2009 |

Adelie | Dream | 41.1 | 17.5 | 190 | 3900 | male | 2009 |

Adelie | Dream | 35.6 | 17.5 | 191 | 3175 | female | 2009 |

Adelie | Dream | 40.2 | 20.1 | 200 | 3975 | male | 2009 |

Adelie | Dream | 37.0 | 16.5 | 185 | 3400 | female | 2009 |

Adelie | Dream | 39.7 | 17.9 | 193 | 4250 | male | 2009 |

Adelie | Dream | 40.2 | 17.1 | 193 | 3400 | female | 2009 |

Adelie | Dream | 40.6 | 17.2 | 187 | 3475 | male | 2009 |

Adelie | Dream | 32.1 | 15.5 | 188 | 3050 | female | 2009 |

Adelie | Dream | 40.7 | 17.0 | 190 | 3725 | male | 2009 |

Adelie | Dream | 37.3 | 16.8 | 192 | 3000 | female | 2009 |

Adelie | Dream | 39.0 | 18.7 | 185 | 3650 | male | 2009 |

Adelie | Dream | 39.2 | 18.6 | 190 | 4250 | male | 2009 |

Adelie | Dream | 36.6 | 18.4 | 184 | 3475 | female | 2009 |

Adelie | Dream | 36.0 | 17.8 | 195 | 3450 | female | 2009 |

Adelie | Dream | 37.8 | 18.1 | 193 | 3750 | male | 2009 |

Adelie | Dream | 36.0 | 17.1 | 187 | 3700 | female | 2009 |

Adelie | Dream | 41.5 | 18.5 | 201 | 4000 | male | 2009 |

Gentoo | Biscoe | 46.1 | 13.2 | 211 | 4500 | female | 2007 |

Gentoo | Biscoe | 50.0 | 16.3 | 230 | 5700 | male | 2007 |

Gentoo | Biscoe | 48.7 | 14.1 | 210 | 4450 | female | 2007 |

Gentoo | Biscoe | 50.0 | 15.2 | 218 | 5700 | male | 2007 |

Gentoo | Biscoe | 47.6 | 14.5 | 215 | 5400 | male | 2007 |

Gentoo | Biscoe | 46.5 | 13.5 | 210 | 4550 | female | 2007 |

Gentoo | Biscoe | 45.4 | 14.6 | 211 | 4800 | female | 2007 |

Gentoo | Biscoe | 46.7 | 15.3 | 219 | 5200 | male | 2007 |

Gentoo | Biscoe | 43.3 | 13.4 | 209 | 4400 | female | 2007 |

Gentoo | Biscoe | 46.8 | 15.4 | 215 | 5150 | male | 2007 |

Gentoo | Biscoe | 40.9 | 13.7 | 214 | 4650 | female | 2007 |

Gentoo | Biscoe | 49.0 | 16.1 | 216 | 5550 | male | 2007 |

Gentoo | Biscoe | 45.5 | 13.7 | 214 | 4650 | female | 2007 |

Gentoo | Biscoe | 48.4 | 14.6 | 213 | 5850 | male | 2007 |

Gentoo | Biscoe | 45.8 | 14.6 | 210 | 4200 | female | 2007 |

Gentoo | Biscoe | 49.3 | 15.7 | 217 | 5850 | male | 2007 |

Gentoo | Biscoe | 42.0 | 13.5 | 210 | 4150 | female | 2007 |

Gentoo | Biscoe | 49.2 | 15.2 | 221 | 6300 | male | 2007 |

Gentoo | Biscoe | 46.2 | 14.5 | 209 | 4800 | female | 2007 |

Gentoo | Biscoe | 48.7 | 15.1 | 222 | 5350 | male | 2007 |

Gentoo | Biscoe | 50.2 | 14.3 | 218 | 5700 | male | 2007 |

Gentoo | Biscoe | 45.1 | 14.5 | 215 | 5000 | female | 2007 |

Gentoo | Biscoe | 46.5 | 14.5 | 213 | 4400 | female | 2007 |

Gentoo | Biscoe | 46.3 | 15.8 | 215 | 5050 | male | 2007 |

Gentoo | Biscoe | 42.9 | 13.1 | 215 | 5000 | female | 2007 |

Gentoo | Biscoe | 46.1 | 15.1 | 215 | 5100 | male | 2007 |

Gentoo | Biscoe | 44.5 | 14.3 | 216 | 4100 | NA | 2007 |

Gentoo | Biscoe | 47.8 | 15.0 | 215 | 5650 | male | 2007 |

Gentoo | Biscoe | 48.2 | 14.3 | 210 | 4600 | female | 2007 |

Gentoo | Biscoe | 50.0 | 15.3 | 220 | 5550 | male | 2007 |

Gentoo | Biscoe | 47.3 | 15.3 | 222 | 5250 | male | 2007 |

Gentoo | Biscoe | 42.8 | 14.2 | 209 | 4700 | female | 2007 |

Gentoo | Biscoe | 45.1 | 14.5 | 207 | 5050 | female | 2007 |

Gentoo | Biscoe | 59.6 | 17.0 | 230 | 6050 | male | 2007 |

Gentoo | Biscoe | 49.1 | 14.8 | 220 | 5150 | female | 2008 |

Gentoo | Biscoe | 48.4 | 16.3 | 220 | 5400 | male | 2008 |

Gentoo | Biscoe | 42.6 | 13.7 | 213 | 4950 | female | 2008 |

Gentoo | Biscoe | 44.4 | 17.3 | 219 | 5250 | male | 2008 |

Gentoo | Biscoe | 44.0 | 13.6 | 208 | 4350 | female | 2008 |

Gentoo | Biscoe | 48.7 | 15.7 | 208 | 5350 | male | 2008 |

Gentoo | Biscoe | 42.7 | 13.7 | 208 | 3950 | female | 2008 |

Gentoo | Biscoe | 49.6 | 16.0 | 225 | 5700 | male | 2008 |

Gentoo | Biscoe | 45.3 | 13.7 | 210 | 4300 | female | 2008 |

Gentoo | Biscoe | 49.6 | 15.0 | 216 | 4750 | male | 2008 |

Gentoo | Biscoe | 50.5 | 15.9 | 222 | 5550 | male | 2008 |

Gentoo | Biscoe | 43.6 | 13.9 | 217 | 4900 | female | 2008 |

Gentoo | Biscoe | 45.5 | 13.9 | 210 | 4200 | female | 2008 |

Gentoo | Biscoe | 50.5 | 15.9 | 225 | 5400 | male | 2008 |

Gentoo | Biscoe | 44.9 | 13.3 | 213 | 5100 | female | 2008 |

Gentoo | Biscoe | 45.2 | 15.8 | 215 | 5300 | male | 2008 |

Gentoo | Biscoe | 46.6 | 14.2 | 210 | 4850 | female | 2008 |

Gentoo | Biscoe | 48.5 | 14.1 | 220 | 5300 | male | 2008 |

Gentoo | Biscoe | 45.1 | 14.4 | 210 | 4400 | female | 2008 |

Gentoo | Biscoe | 50.1 | 15.0 | 225 | 5000 | male | 2008 |

Gentoo | Biscoe | 46.5 | 14.4 | 217 | 4900 | female | 2008 |

Gentoo | Biscoe | 45.0 | 15.4 | 220 | 5050 | male | 2008 |

Gentoo | Biscoe | 43.8 | 13.9 | 208 | 4300 | female | 2008 |

Gentoo | Biscoe | 45.5 | 15.0 | 220 | 5000 | male | 2008 |

Gentoo | Biscoe | 43.2 | 14.5 | 208 | 4450 | female | 2008 |

Gentoo | Biscoe | 50.4 | 15.3 | 224 | 5550 | male | 2008 |

Gentoo | Biscoe | 45.3 | 13.8 | 208 | 4200 | female | 2008 |

Gentoo | Biscoe | 46.2 | 14.9 | 221 | 5300 | male | 2008 |

Gentoo | Biscoe | 45.7 | 13.9 | 214 | 4400 | female | 2008 |

Gentoo | Biscoe | 54.3 | 15.7 | 231 | 5650 | male | 2008 |

Gentoo | Biscoe | 45.8 | 14.2 | 219 | 4700 | female | 2008 |

Gentoo | Biscoe | 49.8 | 16.8 | 230 | 5700 | male | 2008 |

Gentoo | Biscoe | 46.2 | 14.4 | 214 | 4650 | NA | 2008 |

Gentoo | Biscoe | 49.5 | 16.2 | 229 | 5800 | male | 2008 |

Gentoo | Biscoe | 43.5 | 14.2 | 220 | 4700 | female | 2008 |

Gentoo | Biscoe | 50.7 | 15.0 | 223 | 5550 | male | 2008 |

Gentoo | Biscoe | 47.7 | 15.0 | 216 | 4750 | female | 2008 |

Gentoo | Biscoe | 46.4 | 15.6 | 221 | 5000 | male | 2008 |

Gentoo | Biscoe | 48.2 | 15.6 | 221 | 5100 | male | 2008 |

Gentoo | Biscoe | 46.5 | 14.8 | 217 | 5200 | female | 2008 |

Gentoo | Biscoe | 46.4 | 15.0 | 216 | 4700 | female | 2008 |

Gentoo | Biscoe | 48.6 | 16.0 | 230 | 5800 | male | 2008 |

Gentoo | Biscoe | 47.5 | 14.2 | 209 | 4600 | female | 2008 |

Gentoo | Biscoe | 51.1 | 16.3 | 220 | 6000 | male | 2008 |

Gentoo | Biscoe | 45.2 | 13.8 | 215 | 4750 | female | 2008 |

Gentoo | Biscoe | 45.2 | 16.4 | 223 | 5950 | male | 2008 |

Gentoo | Biscoe | 49.1 | 14.5 | 212 | 4625 | female | 2009 |

Gentoo | Biscoe | 52.5 | 15.6 | 221 | 5450 | male | 2009 |

Gentoo | Biscoe | 47.4 | 14.6 | 212 | 4725 | female | 2009 |

Gentoo | Biscoe | 50.0 | 15.9 | 224 | 5350 | male | 2009 |

Gentoo | Biscoe | 44.9 | 13.8 | 212 | 4750 | female | 2009 |

Gentoo | Biscoe | 50.8 | 17.3 | 228 | 5600 | male | 2009 |

Gentoo | Biscoe | 43.4 | 14.4 | 218 | 4600 | female | 2009 |

Gentoo | Biscoe | 51.3 | 14.2 | 218 | 5300 | male | 2009 |

Gentoo | Biscoe | 47.5 | 14.0 | 212 | 4875 | female | 2009 |

Gentoo | Biscoe | 52.1 | 17.0 | 230 | 5550 | male | 2009 |

Gentoo | Biscoe | 47.5 | 15.0 | 218 | 4950 | female | 2009 |

Gentoo | Biscoe | 52.2 | 17.1 | 228 | 5400 | male | 2009 |

Gentoo | Biscoe | 45.5 | 14.5 | 212 | 4750 | female | 2009 |

Gentoo | Biscoe | 49.5 | 16.1 | 224 | 5650 | male | 2009 |

Gentoo | Biscoe | 44.5 | 14.7 | 214 | 4850 | female | 2009 |

Gentoo | Biscoe | 50.8 | 15.7 | 226 | 5200 | male | 2009 |

Gentoo | Biscoe | 49.4 | 15.8 | 216 | 4925 | male | 2009 |

Gentoo | Biscoe | 46.9 | 14.6 | 222 | 4875 | female | 2009 |

Gentoo | Biscoe | 48.4 | 14.4 | 203 | 4625 | female | 2009 |

Gentoo | Biscoe | 51.1 | 16.5 | 225 | 5250 | male | 2009 |

Gentoo | Biscoe | 48.5 | 15.0 | 219 | 4850 | female | 2009 |

Gentoo | Biscoe | 55.9 | 17.0 | 228 | 5600 | male | 2009 |

Gentoo | Biscoe | 47.2 | 15.5 | 215 | 4975 | female | 2009 |

Gentoo | Biscoe | 49.1 | 15.0 | 228 | 5500 | male | 2009 |

Gentoo | Biscoe | 47.3 | 13.8 | 216 | 4725 | NA | 2009 |

Gentoo | Biscoe | 46.8 | 16.1 | 215 | 5500 | male | 2009 |

Gentoo | Biscoe | 41.7 | 14.7 | 210 | 4700 | female | 2009 |

Gentoo | Biscoe | 53.4 | 15.8 | 219 | 5500 | male | 2009 |

Gentoo | Biscoe | 43.3 | 14.0 | 208 | 4575 | female | 2009 |

Gentoo | Biscoe | 48.1 | 15.1 | 209 | 5500 | male | 2009 |

Gentoo | Biscoe | 50.5 | 15.2 | 216 | 5000 | female | 2009 |

Gentoo | Biscoe | 49.8 | 15.9 | 229 | 5950 | male | 2009 |

Gentoo | Biscoe | 43.5 | 15.2 | 213 | 4650 | female | 2009 |

Gentoo | Biscoe | 51.5 | 16.3 | 230 | 5500 | male | 2009 |

Gentoo | Biscoe | 46.2 | 14.1 | 217 | 4375 | female | 2009 |

Gentoo | Biscoe | 55.1 | 16.0 | 230 | 5850 | male | 2009 |

Gentoo | Biscoe | 44.5 | 15.7 | 217 | 4875 | NA | 2009 |

Gentoo | Biscoe | 48.8 | 16.2 | 222 | 6000 | male | 2009 |

Gentoo | Biscoe | 47.2 | 13.7 | 214 | 4925 | female | 2009 |

Gentoo | Biscoe | NA | NA | NA | NA | NA | 2009 |

Gentoo | Biscoe | 46.8 | 14.3 | 215 | 4850 | female | 2009 |

Gentoo | Biscoe | 50.4 | 15.7 | 222 | 5750 | male | 2009 |

Gentoo | Biscoe | 45.2 | 14.8 | 212 | 5200 | female | 2009 |

Gentoo | Biscoe | 49.9 | 16.1 | 213 | 5400 | male | 2009 |

Chinstrap | Dream | 46.5 | 17.9 | 192 | 3500 | female | 2007 |

Chinstrap | Dream | 50.0 | 19.5 | 196 | 3900 | male | 2007 |

Chinstrap | Dream | 51.3 | 19.2 | 193 | 3650 | male | 2007 |

Chinstrap | Dream | 45.4 | 18.7 | 188 | 3525 | female | 2007 |

Chinstrap | Dream | 52.7 | 19.8 | 197 | 3725 | male | 2007 |

Chinstrap | Dream | 45.2 | 17.8 | 198 | 3950 | female | 2007 |

Chinstrap | Dream | 46.1 | 18.2 | 178 | 3250 | female | 2007 |

Chinstrap | Dream | 51.3 | 18.2 | 197 | 3750 | male | 2007 |

Chinstrap | Dream | 46.0 | 18.9 | 195 | 4150 | female | 2007 |

Chinstrap | Dream | 51.3 | 19.9 | 198 | 3700 | male | 2007 |

Chinstrap | Dream | 46.6 | 17.8 | 193 | 3800 | female | 2007 |

Chinstrap | Dream | 51.7 | 20.3 | 194 | 3775 | male | 2007 |

Chinstrap | Dream | 47.0 | 17.3 | 185 | 3700 | female | 2007 |

Chinstrap | Dream | 52.0 | 18.1 | 201 | 4050 | male | 2007 |

Chinstrap | Dream | 45.9 | 17.1 | 190 | 3575 | female | 2007 |

Chinstrap | Dream | 50.5 | 19.6 | 201 | 4050 | male | 2007 |

Chinstrap | Dream | 50.3 | 20.0 | 197 | 3300 | male | 2007 |

Chinstrap | Dream | 58.0 | 17.8 | 181 | 3700 | female | 2007 |

Chinstrap | Dream | 46.4 | 18.6 | 190 | 3450 | female | 2007 |

Chinstrap | Dream | 49.2 | 18.2 | 195 | 4400 | male | 2007 |

Chinstrap | Dream | 42.4 | 17.3 | 181 | 3600 | female | 2007 |

Chinstrap | Dream | 48.5 | 17.5 | 191 | 3400 | male | 2007 |

Chinstrap | Dream | 43.2 | 16.6 | 187 | 2900 | female | 2007 |

Chinstrap | Dream | 50.6 | 19.4 | 193 | 3800 | male | 2007 |

Chinstrap | Dream | 46.7 | 17.9 | 195 | 3300 | female | 2007 |

Chinstrap | Dream | 52.0 | 19.0 | 197 | 4150 | male | 2007 |

Chinstrap | Dream | 50.5 | 18.4 | 200 | 3400 | female | 2008 |

Chinstrap | Dream | 49.5 | 19.0 | 200 | 3800 | male | 2008 |

Chinstrap | Dream | 46.4 | 17.8 | 191 | 3700 | female | 2008 |

Chinstrap | Dream | 52.8 | 20.0 | 205 | 4550 | male | 2008 |

Chinstrap | Dream | 40.9 | 16.6 | 187 | 3200 | female | 2008 |

Chinstrap | Dream | 54.2 | 20.8 | 201 | 4300 | male | 2008 |

Chinstrap | Dream | 42.5 | 16.7 | 187 | 3350 | female | 2008 |

Chinstrap | Dream | 51.0 | 18.8 | 203 | 4100 | male | 2008 |

Chinstrap | Dream | 49.7 | 18.6 | 195 | 3600 | male | 2008 |

Chinstrap | Dream | 47.5 | 16.8 | 199 | 3900 | female | 2008 |

Chinstrap | Dream | 47.6 | 18.3 | 195 | 3850 | female | 2008 |

Chinstrap | Dream | 52.0 | 20.7 | 210 | 4800 | male | 2008 |

Chinstrap | Dream | 46.9 | 16.6 | 192 | 2700 | female | 2008 |

Chinstrap | Dream | 53.5 | 19.9 | 205 | 4500 | male | 2008 |

Chinstrap | Dream | 49.0 | 19.5 | 210 | 3950 | male | 2008 |

Chinstrap | Dream | 46.2 | 17.5 | 187 | 3650 | female | 2008 |

Chinstrap | Dream | 50.9 | 19.1 | 196 | 3550 | male | 2008 |

Chinstrap | Dream | 45.5 | 17.0 | 196 | 3500 | female | 2008 |

Chinstrap | Dream | 50.9 | 17.9 | 196 | 3675 | female | 2009 |

Chinstrap | Dream | 50.8 | 18.5 | 201 | 4450 | male | 2009 |

Chinstrap | Dream | 50.1 | 17.9 | 190 | 3400 | female | 2009 |

Chinstrap | Dream | 49.0 | 19.6 | 212 | 4300 | male | 2009 |

Chinstrap | Dream | 51.5 | 18.7 | 187 | 3250 | male | 2009 |

Chinstrap | Dream | 49.8 | 17.3 | 198 | 3675 | female | 2009 |

Chinstrap | Dream | 48.1 | 16.4 | 199 | 3325 | female | 2009 |

Chinstrap | Dream | 51.4 | 19.0 | 201 | 3950 | male | 2009 |

Chinstrap | Dream | 45.7 | 17.3 | 193 | 3600 | female | 2009 |

Chinstrap | Dream | 50.7 | 19.7 | 203 | 4050 | male | 2009 |

Chinstrap | Dream | 42.5 | 17.3 | 187 | 3350 | female | 2009 |

Chinstrap | Dream | 52.2 | 18.8 | 197 | 3450 | male | 2009 |

Chinstrap | Dream | 45.2 | 16.6 | 191 | 3250 | female | 2009 |

Chinstrap | Dream | 49.3 | 19.9 | 203 | 4050 | male | 2009 |

Chinstrap | Dream | 50.2 | 18.8 | 202 | 3800 | male | 2009 |

Chinstrap | Dream | 45.6 | 19.4 | 194 | 3525 | female | 2009 |

Chinstrap | Dream | 51.9 | 19.5 | 206 | 3950 | male | 2009 |

Chinstrap | Dream | 46.8 | 16.5 | 189 | 3650 | female | 2009 |

Chinstrap | Dream | 45.7 | 17.0 | 195 | 3650 | female | 2009 |

Chinstrap | Dream | 55.8 | 19.8 | 207 | 4000 | male | 2009 |

Chinstrap | Dream | 43.5 | 18.1 | 202 | 3400 | female | 2009 |

Chinstrap | Dream | 49.6 | 18.2 | 193 | 3775 | male | 2009 |

Chinstrap | Dream | 50.8 | 19.0 | 210 | 4100 | male | 2009 |

Chinstrap | Dream | 50.2 | 18.7 | 198 | 3775 | female | 2009 |

Suppose we want to look at flipper length versus body mass. The appropriate command is:

```
gf_point(flipper_length_mm ~ body_mass_g, data = palmerpenguins::penguins)
#> Warning: Removed 2 rows containing missing values (geom_point).
```

Each row in the data frame generates one dot in the plot: the \(y\) and \(x\) coordinates of the dot are set by the value of the variables named in the tilde expression. \(y\) is always the first name, on the left-hand side of the tilde.

There is a wide variety of ways to customize the plot: size, shape, transparency of the dots, etc. A statistics course can show you why you would want to use these modalities. For our purposes in this course, there are just three sorts of customizations:

- Rather than a linear axis (the default), show the data using a log axis. The penguin data is not suitable for an example, because the linear axes work perfectly well. (All penguins are approximately the same size.) So, as an example, we’ll use a very small data set from Robert Boyle’s experiments around 1660 on the relationship bretween the pressure and volume of a gas (at constant temperature).

```
# linear axes: the default
gf_point(pressure ~ volume, data = Boyle)
```

```
# Log-log axes
gf_point(pressure ~ volume, data = Boyle) %>%
gf_refine(scale_x_log10(), scale_y_log10())
```

To make a semi-log plot, use the `scale_y_log10()`

and leave
out the `scale_x_log10()`

argument to
`gf_refine(0)`

.

Note: Log-log or semi-log axes are a valuable way to present data to a human reader, because the value of the variables for any point can be read directly from the axes. But sometimes your purpose is not to present data but to estimate a parameter in a power-law or exponential relationship. For the purpose of estimating parameters, better to make an ordinary plot with linear axes, but plot the log of the variable(s) rather than the variables themselves. For instance:

`gf_point(log(pressure) ~ log(volume), data = Boyle)`

- Using color to display a third variable in a scatter plot. An example with the penguin data will suffice.

```
gf_point(flipper_length_mm ~ body_mass_g,
data = palmerpenguins::penguins,
color = ~ sex)
#> Warning: Removed 2 rows containing missing values (geom_point).
```

Notice the tilde before the variable name in the `color=`

argument. You can also set the color to be a fixed values,
e.g. `color="magenta"`

.

- Set the limits of an axis. Sometimes the upper and lower bounds on
the axes selected by R are inappropriate for your purpose. When this is
the case, you can set the limits yourself by piping the graphic to the
`gf_lims()`

function. For instance, the penguin graph above shows that females have somewhat smaller flipper length than males, and somewhat smaller weights as well. But because zero was not used as the lower limit of the axes, the plot overstates the sex differences. Including zero as an axis limit is often appropriate.

```
gf_point(flipper_length_mm ~ body_mass_g,
data = palmerpenguins::penguins,
color = ~ sex) %>%
gf_lims(y=c(0,235), x=c(0,6500))
#> Warning: Removed 2 rows containing missing values (geom_point).
```

Finding parameters to match a function to data can be a matter of
trial and error. The `fitModel()`

R/mosaic function can be
used to polish a preliminary fit.

For instance, as every chemistry student knows, Boyle’s Law states that at constant temperature, pressure and volume are inversely related: \(P = a V^{-1}\). Let’s see how well Boyle’s data matches his law by fitting a general power-law form \(P = a V^{n}\) to his data.

At the core of `fitModel()`

is a tilde expression that
specifies the name of the function output (on the left side of the
tilde) and a functional form written in terms of the names of the inputs
to the function. Parameters are written using names.

`<- fitModel(pressure ~ a*volume^n, data = Boyle) mod `

The object created by `fitModel()`

is a function of the
variables on the right-hand side of the tilde expression, just
`volume`

here. You can use that mathematical function like
any other that you create with `makeFun()`

or the like. For
instance:

```
gf_point(pressure ~ volume, data = Boyle) %>%
slice_plot(mod(volume) ~ volume, color="magenta")
```

But unlike other functions, you can interrogate the functions produced
by `fitModel(0)`

to see the numerical values of the
parameters. This is done with the `coef()`

function (as in
“coefficients”).

```
coef(mod)
#> a n
#> 1370.8544316 -0.9931137
```

`a`

is
proportional to temperature.
Suppose you were creating a function to represent the distance travelled by an object in free fall as a function of time from some initial point in time \(t_0\). The mathematical relationship is \[\text{dist}(t) \equiv v_0 \left[\strut t - t_0\right] + \frac{1}{2} g \left[\strut t - t_0\right]^2\]

To evaluate this function, you need to know the three parameters \(v_0, t_0,\) and \(g\). On Earth, \(g=-9.8\) meters/sec\(^2\), but you may not know \(v_0\) or \(t_0\) until it comes time to use the function in some context. It’s tempting to put in numerical values for the parameters to make the function easy to use. For instance, if the object starts from rest at time \(t=0\), it would be tempting to make the R definition something like:

`dist <- makeFun(0*(t-0) - 9.8*(t-0)^2 / 2 ~ .)`

or
even `makeFun(-9.8*t^2 / 2 ~ .)`

A better practice is to create the function with the parameter names shown explicitly:

`dist <- makeFun(v0 * (t - t0) + g*(t-t0)^2/2 ~ .)`

Unfortunately, the resulting function will have four arguments which
have to be specified every time you use it. A nice compromise is to
assign ** default values** for the parameters. For
instance \(t_0 = 0\) and \(v_0 = 0\) and \(g
= -9.8\) meters/sec\(^2\) would
be sensible.

You specify the default parameters by adding them as additional arguments after the tilde expression.

`<- makeFun(v0*(t-t0) + g*(t-t0)^2 / 2 ~ ., g=-9.8, v0=0, t0=0) dist `

This way, you can use the function simply when the default parameters are appropriate, or modify them as needed. For instance, the free-fall distance over two seconds:

```
<- dist(2)
on_Earth <- dist(2, g=-3.7) on_Mars
```

“Calculating a derivative” means to find the function that is the
derivative of a specified function. In R/mosaic this can be done in
exactly the same way that `makeFun()`

works. For
instance:

```
<- D(exp(t) * cos(t) ~ t)
df
df#> function (t)
#> cos(t) * exp(t) - sin(t) * exp(t)
slice_plot(df(t) ~ t, bounds(t=0:10))
```

The name on the right-hand side of the tilde expression will be the
“with respect to” variable. If you want a second derivative, use and
expression like `t + t`

on the right-hand side. You can also
calculate mixed partial derivatives with right-hand side expressions
like `t & x`

.

R/mosaic knows how to use both numerical and symbolic methods. To
force the use of numerical methods, use `numD()`

instead of
`D()`

.

Anti-derivatives can be computed with `antiD()`

. For
example:

```
antiD(sin(omega*t) ~ t)
#> function (t, omega, C = 0)
#> C - cos(t * omega)/omega
```

R/mosaic knows only a few symbolic anti-derivatives. When it doesn’t
know the symbolic form, the function produced by `antiD()`

will use numerical methods.

“Solving” means to find an input \(x^\star\) that will generate an output of \(v\) from \(f(x)\). That is, the answer \(x^\star\) will give \(f(x^\star) = v\). There may be no solutions, one solutions, several or many solutions.

In R/mosaic, solving is implemented as the `Zeros()`

function. `Zeros()`

looks for solutions where \(f(x^\star) = 0\), but any solution problem,
regardless of \(v\), can be placed in
this form.

`Zeros()`

is used in the same way as many other R/mosaic
functions: the first argument is a tilde expression, the second is a
bounds. The output will be a data-frame with the solutions found. For
instance, here we find the inputs to \(\sin(x)\) that produce an output of 0.5.
Notice that we have created a new function (\(\sin(x) - 0.5\)) whose output will be zero
at the solutions we seek.

```
<- Zeros(sin(x) - 0.5 ~ x, bounds(x=0:10))
solutions slice_plot(sin(x) ~ x, bounds(x=0:10)) %>%
gf_point(0.5 ~ x, data = solutions)
```

```
solutions#> # A tibble: 4 × 2
#> x .output.
#> <dbl> <dbl>
#> 1 0.524 -0.0000000658
#> 2 2.62 -0.00000731
#> 3 6.81 0.00000389
#> 4 8.90 0.00000192
```

In optimization, you have an objective function \(f(x)\) and you seek the argmin(s) or argmax(es). The textbook introduces optimization using a technique involving differentiating and solving, that is, finding \(x^\star\) such that \(\partial_x f(x^\star) = 0\). We’ll illustrate with a made-up function:

```
<- rfun(~ x, seed=943) # a random function
f slice_plot(f(x) ~ x, bounds(x=-5:5))
```

It’s so easy to spot the argmins and argmaxes from a graph that it’s reasonable to wonder why we need derivatives and solving to do it. The answer is that we are helping you establish a conceptual foundation for more interesting optimization problems where you can’t just look at a graph. So let’s step through the problem formally using derivatives.

- Construct the derivative of the objective function with respect to its argument.

`<- D(f(x) ~ x) df `

If there were symbolic parameters in your definition of \(f()\), you would need to resolve them at this point, assigning the parameters definite numerical values. 2. Find the zeros of the derivative function:

```
<- Zeros(df(x) ~ x, bounds(x=-5:5))
dzeros
dzeros#> # A tibble: 5 × 2
#> x .output.
#> <dbl> <dbl>
#> 1 -4.14 -0.000000647
#> 2 -2.29 0.00000685
#> 3 -0.0973 0.00000215
#> 4 1.43 -0.000000893
#> 5 3.85 -0.000000254
```

The output of `Zeros()`

has two columns. The first lists
the solutions, the second gives the value of the function at those
solutions. Note that the function output is very close to zero, there’s
not really any information there. And there’s nothing that tells you
whether a given \(x\) is an argmax or
an argmin. Of course, you could figure this out by referring to the
graph of \(f(x)\) itself, but let’s be
a little more formal by extracting this information from
`dzeros`

, `f()`

, and the second derivative of
`f()`

. To do this, we introduce a new function,
`mutate()`

, that operates on data frames. And we’ll need the
second derivative \(\partial_{xx}f()\)
to establish whether the function is concave up or down at the solutions
found.

`<- D(f(x) ~ x & x) ddf `

Here’s where `mutate()`

comes in, allowing us to apply the
functions `f()`

and `ddf()`

to the `x`

values in the solution. The first command might look strange. It means,
“Take the old data frame `dzeros`

, add some new columns to it
using `mutate()`

, and then calling the new data frame by the
old name `dzeros`

.

```
<- dzeros %>%
dzeros mutate(val = f(x), convexity = sign(ddf(x)))
dzeros#> # A tibble: 5 × 4
#> x .output. val convexity
#> <dbl> <dbl> <dbl> <dbl>
#> 1 -4.14 -0.000000647 2.22 -1
#> 2 -2.29 0.00000685 0.412 1
#> 3 -0.0973 0.00000215 9.25 -1
#> 4 1.43 -0.000000893 5.47 1
#> 5 3.85 -0.000000254 10.9 -1
```

From the sign of the convexity at the solutions \(x\), you can tell immediately which rows correspond to an argmin (positive convexity) and which to an argmax (negative convexity).

For fun, we can graph our findings on top of the function \(f()\) to confirm that we have things right:

```
slice_plot(f(x) ~ x, bounds(x=-5:5)) %>%
gf_point(val ~ x, data = dzeros, color= ~ convexity)
```

Optimization is such an important procedure that clever algorithms to
handle all sorts of difficulties has been invented. This is an extensive
topic in its own right, but for simplicity, R/mosaic provides a function
`argM()`

that works with functions with multiple inputs,
pretty much automatically. It’s called `argM()`

because it
returns both argmins and argmaxes, along with some supplemental
information.

```
argM(f(x) ~ x, bounds(x=-5:5))
#> # A tibble: 2 × 3
#> x .output. concavity
#> <dbl> <dbl> <dbl>
#> 1 -2.29 0.412 1
#> 2 3.85 10.9 -1
```

`argM()`

will not necessarily find **all**
the local argmins and argmaxes. But it also works for functions with
multiple inputs.

```
<- makeFun(x*sin(sqrt(3+x))*(1+cos(y))-y ~ .)
f2 <- argM(f2(x, y) ~ x & y, bounds(x=c(-3,3), y=c(-3,3)))
solns
solns#> # A tibble: 1 × 3
#> x y .output.
#> <dbl> <dbl> <dbl>
#> 1 -2.21 0.622 -3.73
```

```
contour_plot(f2(x,y) ~ x & y, bounds(x=c(-3,3), y=c(-3,3))) %>%
gf_point(y ~ x, data = solns, color="red")
```

```
<- makeFun(x ~ x)
identity_fun <- makeFun(1 ~ x)
constant_fun <- makeFun(m*x + b ~ x, b=0, m=1)
straight_line <- makeFun(exp(k * x) ~ x, k=1)
exponential <- makeFun(x^p ~ x, p = 1/2)
power_law <- makeFun(sin(2*pi*(t-t0)/P) ~ t, P=2, t0=0)
sinusoid <- makeFun(log(x, base=exp(1)) ~ x)
logarithm <- makeFun(dnorm(x, mean, sd) ~ x, mean=0, sd=1)
gaussian <- makeFun(pnorm(x, mean, sd) ~ x, mean=0, sd=1)
sigmoid
identity_fun(3)
#> [1] 3
constant_fun(3)
#> [1] 1
power_law(3)
#> [1] 1.732051
```

```
# Linear combination (example)
<- makeFun(a0 + a1*exp(k * x) ~ ., a0=30, a1=150, k=-0.5)
f # Product (example)
<- makeFun(dnorm(x, mean=0, sd=3) * sin(2*pi*t/P) ~ ., P=3)
g # Composition (example)
<- makeFun(exp(sin(2*pi*t/P) ~ x) ~ ., P = 3) h
```

```
slice_plot(dnorm(x, mean=1, sd=2) ~ x,
bounds(x=-5:5))
contour_plot(dnorm(x, mean=1, sd=2) * pnorm(y, mean=-3, sd=1) ~ x + y,
bounds(x=-5:5, y=-5:5))
```

```
<- makeFun(exp(-0.5*x) * sin(2*pi*x/3) ~ .)
f <- D(f(x) ~ x)
df slice_plot(df(x) ~ x, bounds(x=-5:5)) %>%
slice_plot(f(x) ~ x, bounds(x=-5:5), color="orange3")
```

```
<- makeFun(dnorm(x, mean=1, sd=2) ~ .)
f <- antiD(f(x) ~ x)
F slice_plot(F(x) ~ x, bounds(x=-5:5)) %>%
slice_plot(f(x) ~ x, color="orange3")
```

```
# Set "constant of integration"
slice_plot(F(x) ~ x, bounds(x=-5:5)) %>%
slice_plot(f(x) ~ x, color="orange3") %>%
slice_plot(F(x, C=0.25) ~ x, color="green")
```

```
# Definite integral
F(5) - F(-5)
#> [1] 0.9759
```

```
<- makeFun(exp(sin(2*pi*x/3)) - 0.5 ~ .)
f <- findZeros(f(x) ~ x, near=0, within=5)
Zeros
Zeros#> x
#> 1 -4.1343
#> 2 -3.3656
#> 3 -1.1344
#> 4 -0.3657
#> 5 1.8656
#> 6 2.6343
#> 7 4.8657
slice_plot(f(x) ~ x, bounds(x=-5:5)) %>%
gf_hline(yintercept=0, color="orange3") %>%
gf_vline(xintercept= ~ x, color="dodgerblue", data=Zeros)
```

Use `fitModel()`

to fit a function of one variable to
data.

- The tilde expression uses the names in the data frame.
- Response variable on left of tilde, formula for function on right.
- Give starting values for any nonlinear parameters (e.g. \(k\) in \(e^kt\) or \(P\) in $( t).

`gf_point(temp ~ time, data = CoolingWater)`

```
# Eyeball half-life at 25
<- -log(2)/25
k0 <- fitModel(temp ~ A + B*exp(-k*time), data=CoolingWater,
mod start=list(k=k0))
<- gf_point(temp ~ time, data = CoolingWater) %>%
Plot slice_plot(mod(time) ~ time, color="dodgerblue", alpha=0.25, size=2)
```

Approximate a function \(f(x)\) around a selected point \(x=x_0\).

```
<- makeFun(exp(-0.5*x)*sin(2*pi*x/3) ~ .)
f
<- D(f(x) ~ x)
df <- 0.9
center_fun_on <- D(df(x) ~ x) # alternatively, D(f(x) ~ x + x)
ddf <- makeFun(f(x0) + df(x0)*(x-x0) ~ x, x0 = center_fun_on)
lin_approx <- makeFun(lin_approx(x) + 0.5*ddf(x0)*(x-x0)^2 ~ x, x0 = center_fun_on)
quad_approx slice_plot(f(x) ~ x, bounds(x=0:1.5), size=2) %>%
slice_plot(lin_approx(x) ~ x, color="blue") %>%
slice_plot(quad_approx(x) ~ x, bounds(x=0:1.5), color="orange") %>%
gf_vline(xintercept = center_fun_on, alpha=0.2, color="yellow", size=3)
```