Deep R Programming

Deep R Programming is a comprehensive and in-depth introductory course on one of the most popular languages for data science. It equips ambitious students, professionals, and researchers with the knowledge and skills to become independent users of this potent environment so that they can tackle any problem related to data wrangling and analytics, numerical computing, statistics, and machine learning.

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

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.

You can also order a paper copy.

Any bug/typo reports/fixes are appreciated. Please submit them via this project’s GitHub repository. Thank you.

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

Make sure to check out Minimalist Data Wrangling with Python [26] too.

Copyright (C) 2022–2023 by Marek Gagolewski. Some rights reserved. This material is published 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. Managing data flow
  • 9.2. Organising and maintaining functions
  • 9.3. Special functions: Syntactic sugar
  • 9.4. Arguments and local variables
  • 9.5. Principles of sustainable design (*)
  • 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. (Over)using the forward pipe operator, `|>` (*)
  • 10.5. S4 classes (*)
  • 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. 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 definition and usage
  • 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