Provides a set of functions for interacting with the 'Digital
Ocean' API at <https://developers.digitalocean.com/documentation/v2>, including
creating images, destroying them, rebooting, getting details on regions, and
available images.

R's raw vector is useful for storing a single
binary object. What if you want to put a vector of them in a data
frame? The 'blob' package provides the blob object, a list of raw
vectors, suitable for use as a column in data frame.

Sending functions to remote processes can be wasteful of
resources because they carry their environments with them. With
the carrier package, it is easy to create functions that are
isolated from their environment. These isolated functions, also
called crates, print at the console with their total size and can
be easily tested locally before being sent to a remote.

R's default conflict management system gives the most recently
loaded package precedence. This can make it hard to detect conflicts,
particularly when they arise because a package update creates ambiguity
that did not previously exist. 'conflicted' takes a different approach,
making every conflict an error and forcing you to choose which function
to use.

The curl() and curl_download() functions provide highly
configurable drop-in replacements for base url() and download.file() with
better performance, support for encryption (https, ftps), gzip compression,
authentication, and other 'libcurl' goodies. The core of the package implements a
framework for performing fully customized requests where data can be processed
either in memory, on disk, or streaming via the callback or connection
interfaces. Some knowledge of 'libcurl' is recommended; for a more-user-friendly
web client see the 'httr' package which builds on this package with http
specific tools and logic.

A 'dplyr' back end for databases that allows you to
work with remote database tables as if they are in-memory data frames.
Basic features works with any database that has a 'DBI' back end; more
advanced features require 'SQL' translation to be provided by the
package author.

Provides a non-drawing graphic device for benchmarking purpose.
In order to properly benchmark graphic drawing code it is necessary
to factor out the device implementation itself so that results are not
related to the specific graphics device used during benchmarking. The
'devoid' package implements a graphic device that accepts all the required
calls from R's graphic engine but performs no action. Apart from
benchmarking it is unlikely that this device has any practical use.

Many models contain tuning parameters (i.e. parameters that cannot be directly estimated from the data). These tools can be used to define objects for creating, simulating, or validating values for such parameters.

The ellipsis is a powerful tool for extending functions. Unfortunately
this power comes at a cost: misspelled arguments will be silently ignored.
The ellipsis package provides a collection of functions to catch problems
and alert the user.

Predictors can be converted to one or more numeric representations using simple generalized linear models <arXiv:1611.09477> or nonlinear models <arXiv:1604.06737>. All encoding methods are supervised.

Fast implementation of a key-value store. Environments are commonly
used as key-value stores, but every time a new key is used, it is added to
R's global symbol table, causing a small amount of memory leakage. This can
be problematic in cases where many different keys are used. Fastmap avoids
this memory leak issue by implementing the map using data structures in C++.

Unlike other tools that dynamically link to the 'Cairo'
stack, 'freetypeharfbuzz' is statically linked to specific
versions of the 'FreeType' and 'harfbuzz' libraries (2.9 and 1.7.6
respectively). This ensures deterministic computation of text box
extents for situations where reproducible results are crucial (for
instance unit tests of graphics).

Provides utilities for working with Google APIs
<https://developers.google.com/apis-explorer>. This includes
functions and classes for handling common credential types and for
preparing, executing, and processing HTTP requests.

The grammar of graphics as implemented in the 'ggplot2' package has
been successful in providing a powerful API for creating static
visualisation. In order to extend the API for animated graphics this package
provides a completely new set of grammar, fully compatible with 'ggplot2'
for specifying transitions and animations in a flexible and extensible way.

The aim of 'ggplot2' is to aid in visual data investigations. This
focus has led to a lack of facilities for composing specialised plots.
'ggforce' aims to be a collection of mainly new stats and geoms that fills
this gap. All additional functionality is aimed to come through the official
extension system so using 'ggforce' should be a stable experience.

A system for 'declaratively' creating graphics,
based on "The Grammar of Graphics". You provide the data, tell 'ggplot2'
how to map variables to aesthetics, what graphical primitives to use,
and it takes care of the details.

The grammar of graphics as implemented in ggplot2 is a poor fit for
graph and network visualizations due to its reliance on tabular data input.
ggraph is an extension of the ggplot2 API tailored to graph visualizations
and provides the same flexible approach to building up plots layer by layer.

Provides a mechanism to plot a 'Google Map' from 'R' and overlay
it with shapes and markers. Also provides access to 'Google Maps' APIs,
including places, directions, roads, distances, geocoding, elevation and
timezone.

Tools to make it easier to work with "tables" of
'grobs'. The 'gtable' package defines a 'gtable' grob class that specifies a
grid along with a list of grobs and their placement in the grid. Further the
package makes it easy to manipulate and combine 'gtable' objects so that
complex compositions can be build up sequentially.

Read hierarchical fixed width files like those commonly used by
many census data providers. Also allows for reading of data in chunks,
and reading 'gzipped' files without storing the full file in memory.

Useful tools for working with HTTP organised by
HTTP verbs (GET(), POST(), etc). Configuration functions make it easy
to control additional request components (authenticate(),
add_headers() and so on).

Provides a progress bar similar to 'dplyr' that can write progress out to a
variety of locations, including stdout(), stderr(), or from file(). Useful when using 'knitr' or 'rmarkdown',
and you still want to see progress of calculations in the terminal.

Create and customize interactive maps using the 'Leaflet'
JavaScript library and the 'htmlwidgets' package. These maps can be used
directly from the R console, from 'RStudio', in Shiny applications and R Markdown
documents.

ggsubplot makes it easy to embed customized subplots within larger
graphics. Subplots may be used as a geom to explore interaction effects,
spatial data, and hierarchical data. Subplots can also be used to explore
big data without overplotting.

Build display tables from tabular data using with an easy-to-use
API. With its progressive approach, we can construct display tables with a
clear separation of concerns: you don't have to decide how the tabular data
gets transformed and structured whilst also worrying about aesthetics.

Interactive plotting functions for use within RStudio.
The manipulate function accepts a plotting expression and a set of
controls (e.g. slider, picker, checkbox, or button) which are used
to dynamically change values within the expression. When a value is
changed using its corresponding control the expression is
automatically re-executed and the plot is redrawn.

The goal of 'pak' is to make package installation faster and
more reliable. In particular, it performs all HTTP operations in parallel,
so metadata resolution and package downloads are fast. Metadata and package
files are cached on the local disk as well. 'pak' has a dependency solver,
so it finds version conflicts before performing the installation. This
version of 'pak' supports CRAN, 'Bioconductor' and 'GitHub' packages as well.

Generate an attractive and useful website from a source package.
'pkgdown' converts your documentation, vignettes, 'README', and more to
'HTML' making it easy to share information about your package online.

Models can be improved by post-processing class probabilities, by: recalibration, conversion to hard probabilities, assessment of equivocal zones, and other activities. 'probably' contains tools for conducting these operations.

Tools to run system processes in the background.
It can check if a background process is running; wait on a background
process to finish; get the exit status of finished processes; kill
background processes. It can read the standard output and error of
the processes, using non-blocking connections. 'processx' can poll
a process for standard output or error, with a timeout. It can also
poll several processes at once.

Provides fundamental abstractions for doing asynchronous programming
in R using promises. Asynchronous programming is useful for allowing a single
R process to orchestrate multiple tasks in the background while also attending
to something else. Semantics are similar to 'JavaScript' promises, but with a
syntax that is idiomatic R.

Anti-Grain Geometry (AGG) is a high-quality and high-performance
2D drawing library. The 'ragg' package provides a set of graphic devices
based on AGG to use as alternative to the raster devices provided through
the 'grDevices' package.

Building interactive web applications with R is incredibly easy
with 'shiny'. Behind the scenes, 'shiny' builds a reactive graph that can
quickly become intertwined and difficult to debug. 'reactlog'
(Schloerke 2019) <doi:10.5281/zenodo.2591517> provides a visual insight into
that black box of 'shiny' reactivity by constructing a directed dependency
graph of the application's reactive state at any time point in a reactive
recording.

The goal of 'readr' is to provide a fast and friendly way to read
rectangular data (like 'csv', 'tsv', and 'fwf'). It is designed to flexibly
parse many types of data found in the wild, while still cleanly failing when
data unexpectedly changes.

An extensible framework to create and preprocess
design matrices. Recipes consist of one or more data manipulation
and analysis "steps". Statistical parameters for the steps can
be estimated from an initial data set and then applied to
other data sets. The resulting design matrices can then be used
as inputs into statistical or machine learning models.

Download and install R packages stored in 'GitHub',
'BitBucket', or plain 'subversion' or 'git' repositories. This package
provides the 'install_*' functions in 'devtools'.
Indeed most of the code was copied over from 'devtools'.

Convenience wrapper that uses the 'rmarkdown' package to render
small snippets of code to target formats that include both code and output.
The goal is to encourage the sharing of small, reproducible, and runnable
examples on code-oriented websites, such as <https://stackoverflow.com> and
<https://github.com>, or in email. The user's clipboard is the default source
of input code and the default target for rendered output. 'reprex' also
extracts clean, runnable R code from various common formats, such as
copy/paste from an R session.

Interface to 'Python' modules, classes, and functions. When calling
into 'Python', R data types are automatically converted to their equivalent 'Python'
types. When values are returned from 'Python' to R they are converted back to R
types. Compatible with all versions of 'Python' >= 2.7.

It allows to rapidly compute, bootstrap and plot up to third-order Sobol' indices
using the estimators by Saltelli et al. 2010 <doi:10.1016/j.cpc.2009.09.018> and
Jansen 1999 <doi:10.1016/S0010-4655(98)00154-4>. The 'sensobol' package also implements
the algorithm by Khorashadi Zadeh et al. 2017 <doi:10.1016/j.envsoft.2017.02.001> to
calculate the approximation error in the computation of Sobol' first and
total indices, an approach that allows to robustly screen influential from non-influential
model inputs. Finally, it also provides functions to obtain publication-ready figures
of the model output uncertainty and sensitivity-related analysis.

Provides Bootstrap 2 web components for use with the Shiny
package. With versions of Shiny prior to 0.11, these Bootstrap 2 components
were included as part of the package. Later versions of Shiny include
Bootstrap 3, so the Bootstrap 2 components have been moved into this
package for those uses who rely on features specific to Bootstrap 2.

Modifies the progress() function from 'httr' package to let it
send output to progressBar() function from 'shinyWidgets' package.
It is just a tweak at the original functions from 'httr' package to
make it smooth for 'shiny' developers.

A consistent, simple and easy to use set of
wrappers around the fantastic 'stringi' package. All function and
argument names (and positions) are consistent, all functions deal with
"NA"'s and zero length vectors in the same way, and the output from
one function is easy to feed into the input of another.

The goal of 'pkg' is to make package installation faster and
more reliable. In particular, it performs all HTTP operations in parallel,
so metadata resolution and package downloads are fast. Metadata and package
files are cached on the local disk as well. 'pkg' has a dependency solver,
so it finds version conflicts before performing the installation. This
version of 'pkg' supports CRAN, 'BioConductor' and 'GitHub' packages as well.

A dependency management toolkit for R. Using 'renv', you can create
and manage project-local R libraries, save the state of these libraries to
a 'lockfile', and later restore your library as required. Together, these
tools can help make your projects more isolated, portable, and reproducible.

Provides system native access to the font catalogue. As font
handling varies between systems it is difficult to correctly locate
installed fonts across different operating systems. The 'systemfonts'
package provides bindings to the native libraries on Windows, macOS and
Linux for finding font files that can then be used further by e.g. graphic
devices. The main use is intended to be from compiled code but 'systemfonts'
also provides access from R.

Software testing is important, but, in part because it is
frustrating and boring, many of us avoid it. 'testthat' is a testing framework
for R that is easy to learn and use, and integrates with your existing 'workflow'.

Interface to 'TensorFlow' Datasets, a high-level library for
building complex input pipelines from simple, re-usable pieces.
See <https://www.tensorflow.org/programmers_guide/datasets> for additional
details.

Interface to 'TensorFlow' Estimators
<https://www.tensorflow.org/programmers_guide/estimators>, a high-level
API that provides implementations of many different model types
including linear models and deep neural networks.

Bayesian analysis used here to answer the question: "when looking at resampling results, are the differences between models 'real'?" To answer this, a model can be created were the performance statistic is the resampling statistics (e.g. accuracy or RMSE). These values are explained by the model types. In doing this, we can get parameter estimates for each model's affect on performance and make statistical (and practical) comparisons between models. The methods included here are similar to Benavoli et al (2017) <http://jmlr.org/papers/v18/16-305.html>.

A backend for the selecting functions of the 'tidyverse'.
It makes it easy to implement select-like functions in your own
packages in a way that is consistent with other 'tidyverse'
interfaces for selection.

The 'tidyverse' is a set of packages that work in harmony
because they share common data representations and 'API' design. This
package is designed to make it easy to install and load multiple
'tidyverse' packages in a single step. Learn more about the 'tidyverse'
at <https://tidyverse.org>.

Imports non-tabular from Excel files into R. Exposes cell content,
position and formatting in a tidy structure for further manipulation.
Tokenizes Excel formulas. Supports '.xlsx' and '.xlsm' via the embedded
'RapidXML' C++ library <http://rapidxml.sourceforge.net>. Does not support
'.xlsb' or '.xls'.

Defines new notions of prototype and size that are used
to provide tools for consistent and well-founded type-coercion and
size-recycling, and are in turn connected to ideas of type- and
size-stability useful for analyzing function interfaces.

The goal of 'vroom' is to read and write data (like
'csv', 'tsv' and 'fwf') quickly. When reading it uses a quick initial
indexing step, then reads the values lazily , so only the data you
actually use needs to be read. The writer formats the data in
parallel and writes to disk asynchronously from formatting.

A set of functions to run code 'with' safely and temporarily
modified global state. Many of these functions were originally a part of the
'devtools' package, this provides a simple package with limited dependencies
to provide access to these functions.