Deep R Programming

Deep R Programming by Marek Gagolewski is a comprehensive course on one of the most popular languages for data science (statistical computing, graphics, machine learning, data wrangling and analytics). It introduces the base language in-depth. It is aimed at ambitious students, professionals, and researchers who want to become independent users of this powerful environment.

Although available online, this is a whole course. It should be read from the beginning to the end. In particular, refer to the Preface for general introductory remarks.

This early draft is distributed in the hope that it will be useful.

For many students around the world, educational resources are hardly affordable. Therefore, I have decided that this book should remain an independent, non-profit, open-access project (available both in PDF and HTML forms). Whilst, for some people, the presence of a “designer tag” from a major publisher might still be a proxy for quality, it is my hope that this publication will prove useful to those seeking knowledge for knowledge’s sake.

Please spread the news about it by sharing the above URLs with your mates, peers, or students. Thank you.

Also, check out my other book, Minimalist data wrangling with Python [26].

Any bug/typo reports/fixes are appreciated: please submit them via this project’s GitHub repository.

Consider citing this book as: Gagolewski M. (2023), Deep R Programming, Zenodo, Melbourne, DOI: 10.5281/zenodo.7490464, ISBN: 978-0-6455719-2-9, URL: https://deepr.gagolewski.com/.

Copyright (C) 2022–2023 by Marek Gagolewski. Some rights reserved.

This material is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License (CC BY-NC-ND 4.0).

Start here

• Preface
  • To R, or not to R
  • R (GNU S) as a language and an environment
  • Aims, scope, and design philosophy
  • Classification of R data types and book structure
  • About the author
  • Acknowledgements
  • You can make this book better

Deep

• 1. Introduction
  • 1.1. Hello, world!
  • 1.2. Setting up the development environment
  • 1.3. Atomic vectors at a glance
  • 1.4. Getting help
  • 1.5. Exercises
• 2. Numeric vectors
  • 2.1. Creating numeric vectors
  • 2.2. Creating named objects
  • 2.3. Vectorised mathematical functions
  • 2.4. Arithmetic operations
  • 2.5. Exercises
• 3. Logical vectors
  • 3.1. Creating logical vectors
  • 3.2. Comparing elements
  • 3.3. Logical operations
  • 3.4. Choosing elements with ifelse
  • 3.5. Exercises
• 4. Lists and attributes
  • 4.1. Type hierarchy and conversion
  • 4.2. Lists
  • 4.3. NULL
  • 4.4. Object attributes
  • 4.5. Exercises
• 5. Vector indexing
  • 5.1. head and tail
  • 5.2. Subsetting and extracting from vectors
  • 5.3. Replacing elements
  • 5.4. Functions related to indexing
  • 5.5. Preserving and losing attributes
  • 5.6. Exercises
• 6. Character vectors
  • 6.1. Creating character vectors
  • 6.2. Pattern searching
  • 6.3. Other string operations
  • 6.4. Other atomic vector types (*)
  • 6.5. Exercises
• 7. Functions
  • 7.1. Creating and invoking functions
  • 7.2. Functional programming
  • 7.3. Accessing third-party functions
  • 7.4. Exercises
• 8. Flow of execution
  • 8.1. Conditional evaluation
  • 8.2. Exception handling
  • 8.3. Repeated evaluation
  • 8.4. Exercises

Deeper

• 9. Designing functions
  • 9.1. Principles of sustainable design
  • 9.2. Managing data flow
  • 9.3. Organising and maintaining functions
  • 9.4. Special functions: Syntactic sugar
  • 9.5. Arguments and local variables
  • 9.6. Exercises
• 10. S3 classes
  • 10.1. Object type vs class
  • 10.2. Generics and method dispatching
  • 10.3. Common built-in S3 classes
  • 10.4. Argument checking revisited
  • 10.5. (Over)using the forward-pipe operator, `|>` (*)
  • 10.6. Exercises
• 11. Matrices and other arrays
  • 11.1. Creating arrays
  • 11.2. Array indexing
  • 11.3. Common operations
  • 11.4. Numerical matrix algebra (*)
  • 11.5. S4 classes (*)
  • 11.6. Exercises
• 12. Data frames
  • 12.1. Creating data frames
  • 12.2. Data frame subsetting
  • 12.3. Common operations
  • 12.4. Exercises
• 13. Graphics
  • 13.1. Graphics primitives
  • 13.2. Graphics settings
  • 13.3. Higher-level functions
  • 13.4. Exercises

Deepest

• 14. Interfacing compiled code (**)
  • 14.1. C and C++ code in R
  • 14.2. Handling basic types
  • 14.3. Dealing with compound types
  • 14.4. Using existing function libraries
  • 14.5. Exercises
• 15. Unevaluated expressions (*)
  • 15.1. Expressions at a glance
  • 15.2. Language objects
  • 15.3. Calls as combinations of expressions
  • 15.4. Inspecting function definitions and arguments thereto
  • 15.5. Exercises
• 16. Environments and evaluation (*)
  • 16.1. Frames: Environments as object containers
  • 16.2. The environment model of evaluation
  • 16.3. Closures
  • 16.4. Exercises
• 17. Lazy evaluation (**)
  • 17.1. Evaluation of function arguments
  • 17.2. Evaluation of default arguments
  • 17.3. Ellipsis, `...`, revisited
  • 17.4. on.exit (*)
  • 17.5. Metaprogramming and laziness in action: Examples (*)
  • 17.6. Processing formulae, `~` (*)
  • 17.7. Exercises
  • 17.8. Outro

Appendix

• Changelog
• References