R Programming

  1. R Data Types
    1. Understanding R's Type System
      1. Atomic Types vs. Composite Types
        1. Type Hierarchy
          1. Dynamic Typing Nature
          2. Atomic Vector Types
            1. Numeric Types
              1. Integer Type
                1. Double (Floating Point) Type
                  1. Numeric Precision
                    1. Scientific Notation
                    2. Character Type
                      1. String Creation
                        1. String Literals
                          1. Escape Sequences
                            1. Unicode Support
                            2. Logical Type
                              1. TRUE and FALSE Values
                                1. Logical Operations
                                  1. Boolean Algebra
                                  2. Complex Type
                                    1. Complex Number Creation
                                      1. Real and Imaginary Parts
                                        1. Complex Arithmetic
                                        2. Raw Type
                                          1. Byte-level Data
                                            1. Raw Data Operations
                                          2. Special Values and Constants
                                            1. Missing Values (`NA`)
                                              1. Different Types of NA
                                                1. Testing for Missing Values
                                                  1. Handling Missing Data
                                                  2. Not a Number (`NaN`)
                                                    1. Mathematical Undefined Results
                                                      1. Testing for NaN
                                                      2. Infinity Values
                                                        1. Positive Infinity (`Inf`)
                                                          1. Negative Infinity (`-Inf`)
                                                            1. Testing for Infinity
                                                            2. NULL Values
                                                              1. Representing Absence
                                                                1. NULL vs. NA Differences
                                                                  1. Testing for NULL
                                                                2. Type Checking and Conversion
                                                                  1. Type Inspection Functions
                                                                    1. `class()` Function
                                                                      1. `typeof()` Function
                                                                        1. `mode()` Function
                                                                          1. `storage.mode()` Function
                                                                          2. Type Testing Functions
                                                                            1. `is.numeric()`
                                                                              1. `is.character()`
                                                                                1. `is.logical()`
                                                                                  1. `is.complex()`
                                                                                    1. `is.raw()`
                                                                                      1. `is.na()`
                                                                                        1. `is.null()`
                                                                                          1. `is.infinite()`
                                                                                            1. `is.nan()`
                                                                                            2. Type Coercion
                                                                                              1. Implicit Coercion Rules
                                                                                                1. Coercion Hierarchy
                                                                                                  1. Explicit Coercion Functions
                                                                                                    1. `as.numeric()`
                                                                                                      1. `as.character()`
                                                                                                        1. `as.logical()`
                                                                                                          1. `as.complex()`
                                                                                                            1. `as.raw()`
                                                                                                            2. Handling Coercion Warnings

                                                                                                        Previous

                                                                                                        3. R Fundamentals

                                                                                                        Go to top

                                                                                                        Next

                                                                                                        5. R Data Structures