```
library(tinyplot)
= transform(
aq
airquality,Month = factor(Month, labels = month.abb[unique(Month)]),
Hot = Temp > median(Temp)
)
```

# Plot types

**tinyplot** is a lightweight extension of R’s base plotting system, designed to simplify and enhance data visualization. One of its key features is the `type`

argument, which allows you to specify different types of plots easily. This tutorial will guide you through the various plot types available in **tinyplot**, demonstrating how to use the `type`

argument to create a wide range of visualizations.

We will consider three categories of plot types:

- Base types
**tinyplot**types- Custom types

We will use the built-in `airquality`

dataset for our examples:

## Base types

The `type`

argument in `tinyplot`

supports all the standard plot types from base R’s `plot`

function. These are specified using single-character strings.

`"p"`

(Points): Produces a scatter plot of points. This is (usually) the default plot type.`"l"`

(Lines): Produces a line plot.`"b"`

(Points and Lines): Combines points and lines in same the plot.`"c"`

(Empty Points Joined by Lines): Plots empty points connected by lines.`"o"`

(Overplotted Points and Lines): Overlaps points and lines.`"s"`

and`"S"`

(Stair Steps): Creates a step plot.`"h"`

(Histogram-like Vertical Lines): Plots vertical lines resembling a histogram.`"n"`

(Empty Plot): Creates an empty plot frame without data.

For example, we can use `"b"`

to create a plot with combined points and lines.

`tinyplot(Temp ~ Day | Month, data = aq, type = "b", main = "Points and lines")`

## tinyplot types

Beyond the base types, **tinyplot** introduces additional plot types for more advanced visualizations. Each of these additional types are available either as a convenience string (with default behaviour) or a companion `type_*()`

function (with options for customized behaviour).

Models:

`"loess"`

/`type_loess()`

: Local regression curve.`"lm"`

/`type_lm()`

: Linear regression line.`"glm"`

/`type_glm()`

: Generalized linear model fit.`"spline"`

/`type_spline()`

: Cubic (or Hermite) spline interpolation.

Shapes:

`area`

/`type_area()`

: Plots the area under the curve from`y`

= 0 to`y`

= f(`x`

).`rect`

/`type_area()`

: Draws rectangles; requires`xmin`

,`xmax`

,`ymin`

, and`ymax`

.`ribbon`

/`type_ribbon()`

: Creates a filled area between`ymin`

and`ymax`

.`"segments"`

/`type_segements()`

: Draws line segments between pairs of points.`"polygon"`

/`type_polygon()`

: Draws polygons.`"polypath"`

/`type_polypath()`

: Draws a path whose vertices are given in`x`

and`y`

.`"errorbar"`

/`type_errorbar()`

: Adds error bars to points; requires`ymin`

and`ymax`

.`pointrange`

/`type_pointrange`

: Combines points with error bars.

Visualizations:

`"boxplot"`

/`type_boxplot()`

: Creates a box-and-whisker plot.`"density"`

: Plots the density estimate of a variable.`"histogram"`

/`type_histogram()`

: Creates a histogram of a single variable.`"jitter"`

/`type_jitter()`

: Jittered points.`"spineplot"`

/`type_spineplot()`

: Creates a spineplot or spinogram.

To see the difference between the convenience strings and their respective companion `type_*`

functions, let’s quickly walk through two examples.

**Example 1: jittering.** We can add noise to data points using jittering. This allows us to avoid overplotting and can be useful to visualize discrete variables. On the left, we use the `"jitter`

string shortcut with default settings. On the right, we use the `type_jitter()`

function to reduce the amount of jittering.

```
tinyplot(
~ Month, data = aq, main = "Default jittering",
Temp type = "jitter"
)tinyplot(
~ Month, data = aq, main = "Modest jittering",
Temp type = type_jitter(amount = 0.05)
)
```

**Example 2: Logit fit.** In this example, we use `type_glm()`

to fit a logistic regression model to the data, but with different confidence intervals.^{1}

```
tinyplot(
~ Wind, data = aq, main = "Logit with 95% interval",
Hot type = type_glm(family = "binomial")
)tinyplot(
~ Wind, data = aq, main = "Logit with 50% interval",
Hot type = type_glm(family = "binomial", level = 0.5)
)
```

To see what arguments are available for each type, simply consult the type-specific documentation.

```
?type_jitter
?type_glm# etc
```

Finally, please note that all **tinyplot** types support grouping and faceting.

`tinyplot(Temp ~ Wind | Month, data = aq, facet = "by", type = "lm")`

## Custom types

It is easy to add custom types to **tinyplot**. Users who need highly customized plots, or developers who want to add support to their package or functions, only need to define three simple functions: `data_typename()`

, `draw_typename()`

, and `type_typename()`

.

In this section, we explain the role of each of these functions and present a minimalist example of a custom type. Interested readers may refer to the **tinyplot** source code to see many more examples, since each **tinyplot** type is itself implemented as a custom type.

The three functions that we need to define for a new type are:

`data_*()`

: Function factory.- Accepts a list of internal objects
- Inputs must include
`...`

`datapoints`

Is the most important object. It is a data frame with the datapoints to plot.- Other objects that can be modified by
`data_*()`

include:`by`

,`facet`

,`ylab`

,`palette`

- Inputs must include
- Returns a named list with modified versions of those objects.

- Accepts a list of internal objects
`draw_*()`

: Function factory.- Accepts information about data point values and aesthetics.
- Inputs must include
`...`

- The
`i`

prefix in argument names indicates that we are operating on a subgroup of the data, identified by`facet`

or using the`|`

operator in a formula. - Available arguments are:
`ibg`

,`icol`

,`ilty`

,`ilwd`

,`ipch`

,`ix`

,`ixmax`

,`ixmin`

,`iy`

,`iymax`

,`iymin`

,`cex`

,`dots`

,`type`

,`x_by`

,`i`

,`facet_by`

,`by_data`

,`facet_data`

,`flip`

- Inputs must include
- Returns a function which can call base R to draw the plot.

- Accepts information about data point values and aesthetics.
`type_*()`

: A wrapper function that returns a named list with three elements:`draw`

`data`

`name`

Here is a minimalist example of a custom type that logs both `x`

and `y`

and plots lines.

```
= function(base = exp(1)) {
type_log
= function() {
data_log = function(datapoints, ...) {
fun $x = log(datapoints$x, base = base)
datapoints$y = log(datapoints$y, base = base)
datapoints= datapoints[order(datapoints$x), ]
datapoints return(list(datapoints = datapoints, ...))
}return(fun)
}
= function() {
draw_log = function(ix, iy, icol, ...) {
fun points(
x = ix,
y = iy,
col = icol
)
}return(fun)
}
= list(
out draw = draw_log(),
data = data_log(),
name = "log"
)class(out) = "tinyplot_type"
return(out)
}
tinyplot(mpg ~ wt | factor(am), data = mtcars,
type = type_log(), main = "Ln")
tinyplot(mpg ~ wt | factor(am), data = mtcars,
type = type_log(base = 10), main = "Log 10")
```

To underscore what we said above, the **tinyplot** source code contains many examples of type constructor functions that should provide a helpful starting point for custom plot types. Failing that, the **tinyplot** team are always happy to help guide users on how to create their own types and re-purpose existing **tinyplot** code. Just let us know by raising an issue on our GitHub repo.

## Footnotes

Note: If we simply specified the

`"glm"`

convenience string on its own, we’d get a linear fit since the default family is`gaussian`

.↩︎