R courses

start a new graph while keeping the old ones visible with R To start a new graph while keeping the old ones visible with RTo start a new graph while keeping the old ones visible, you can use the par() function in R to manage the graphical parameters. Here’s how you can handle multiple plots in the same plotting area: Using par(mfrow=…) for Multiple Plots in One Window The par(mfrow=…) function allows you to arrange multiple plots in a single plotting window. This is useful for comparing different plots side by side or in a grid. Example:  x <- 1:10 y <- x^2 z <- x^3 # Set up a 2×2 plotting area par(mfrow = c(2, 2)) # Plot 1 plot(x, y, main = “Plot 1: x vs x^2”) # Plot 2 plot(x, z, main = “Plot 2: x vs x^3”) # Plot 3 hist(y, main = “Plot 3: Histogram of x^2”) # Plot 4 boxplot(x, y, main = “Plot 4: Boxplot”) par(mfrow = c(2, 2)): Divides the plotting window into a 2×2 grid. Using par(mfcol=…) for Filling by Column Similar to mfrow, mfcol fills plots column-wise instead of row-wise. Example:  # Set up a 2×2 plotting area, filling by column par(mfcol = c(2, 2)) # Plot 1 plot(x, y, main = “Plot 1: x vs x^2”) # Plot 2 plot(x, z, main = “Plot 2: x vs x^3”) # Plot 3 hist(y, main = “Plot 3: Histogram of x^2”) # Plot 4 boxplot(x, y, main = “Plot 4: Boxplot”) Adding New Plots to the Same Graph If you want to add a new plot to an existing one without clearing the previous plot, use the add = TRUE argument in plotting functions or just overlay plots. Example:  # Initial plot plot(x, y, main = “Overlay Plot”, xlab = “X”, ylab = “Y”, col = “blue”) # Add another plot on top points(x, z, col = “red”) points(): Adds points to an existing plot. Saving and Restoring Graphical Parameters You might want to save the current graphical parameters and restore them later. Example:  # Save current parameters old_par <- par() # Set up a new plotting area par(mfrow = c(1, 2)) # Create plots plot(x, y, main = “Plot 1”) plot(x, z, main = “Plot 2”) # Restore old parameters par(old_par) old_par <- par(): Saves the current graphical parameters. par(old_par): Restores the saved parameters. Opening a New Graphics Device To keep old plots while starting a new one, open a new graphics device using functions like windows(), quartz(), or x11() depending on your operating system. Example:  # Open a new graphics window windows()  # Use quartz() on macOS or x11() on Linux # Create a new plot in the new window plot(x, y, main = “New Plot in New Window”) windows(), quartz(), x11(): Open new graphics devices. Conclusion These methods allow you to manage multiple plots effectively, whether you want to view them together in a single window or keep old plots visible while creating new ones. Experimenting with par() and different graphics devices will help you find the best approach for your needs.

Adding Points with the points() Function Basic Usage The points() function adds points to an existing plot created with plot(). The basic syntax is:  points(x, y, col = “black”, pch = 1, cex = 1) x: Numeric vector of x-coordinates. y: Numeric vector of y-coordinates. col: Color of the points. pch: Plotting character (symbol) to use. cex: Character expansion factor (size of the points). Example:  # Create a base plot x <- 1:10 y <- x^2 plot(x, y, main = “Adding Points Example”, xlab = “X”, ylab = “Y”) # Add additional points new_x <- c(2.5, 4.5, 6.5) new_y <- c(8, 20, 40) points(new_x, new_y, col = “red”, pch = 17, cex = 2) plot(): Creates the initial scatter plot. points(): Adds red, triangular points to the existing plot. Customizing Point Appearance You can customize the appearance of points using various parameters. col: Defines the color of the points. You can use named colors or RGB values. pch: Defines the symbol used for the points. Common symbols are: 1: Circle 2: Triangle 3: Plus sign 4: Cross 16: Filled circle cex: Adjusts the size of the points. The default is 1; values greater than 1 increase the size. Example:  # Create a base plot plot(x, y, main = “Customized Points”, xlab = “X”, ylab = “Y”) # Add customized points points(new_x, new_y, col = “blue”, pch = 19, cex = 1.5) pch = 19: Adds filled circles. cex = 1.5: Increases the point size. Adding Points with Different Attributes You can add points with different colors, sizes, and symbols to highlight specific data. Example:  # Create a base plot plot(x, y, main = “Different Points Attributes”, xlab = “X”, ylab = “Y”) # Add points with different attributes points(c(1, 2, 3), c(1, 4, 9), col = “green”, pch = 15, cex = 2) points(c(7, 8, 9), c(49, 64, 81), col = “purple”, pch = 17, cex = 1.2) pch = 15: Adds filled squares. pch = 17: Adds filled triangles. cex: Adjusts the size for each set of points. Adding Points to Existing Plot To add points to a plot after it has been created, ensure you use the points() function on the existing plot. Example:  # Create the initial plot plot(x, y, main = “Adding Points to Existing Plot”, xlab = “X”, ylab = “Y”) # Add points to the existing plot additional_x <- c(5, 7, 9) additional_y <- c(25, 49, 81) points(additional_x, additional_y, col = “orange”, pch = 8, cex = 1.8) pch = 8: Adds asterisk symbols. Adding Points with Transparency To make points semi-transparent, you can use RGB colors with transparency. Example:  # Create the initial plot plot(x, y, main = “Transparent Points”, xlab = “X”, ylab = “Y”) # Add semi-transparent points points(new_x, new_y, col = rgb(1, 0, 0, 0.5), pch = 16, cex = 2)  # Red with 50% transparency rgb(r, g, b, alpha): Defines color with transparency (alpha). Summary Basic Usage: Use points() to add points to an existing plot. Customization: Modify col, pch, and cex to change appearance. Different Attributes: Add points with various colors, sizes, and symbols. Adding to Existing Plot: Ensure you add points after the plot is created. Transparency: Use rgb() with the alpha parameter for semi-transparent points.

Creating Three-Dimensional Plots in R Three-dimensional (3D) plots provide a way to visualize data in three dimensions, which can be especially useful for understanding complex datasets. R offers several packages and functions for creating 3D plots. Here’s a detailed overview of the methods and examples. Base R 3D Plotting R’s base package includes functions for basic 3D plotting, such as persp(), contour3d(), and scatterplot3d(). persp() Function The persp() function creates a 3D perspective plot of a surface. Example: Basic 3D Surface Plot  # Generate sample data x <- seq(-10, 10, length = 30) y <- seq(-10, 10, length = 30) z <- outer(x, y, function(x, y) { sin(sqrt(x^2 + y^2)) }) # Create 3D surface plot persp(x, y, z, main = “3D Surface Plot”, xlab = “X”, ylab = “Y”, zlab = “Z”, col = “lightblue”) x, y, z: Coordinates for the surface. col: Color of the surface. scatterplot3d Package The scatterplot3d package offers a straightforward way to create 3D scatter plots. Installation  install.packages(“scatterplot3d”)  Example: 3D Scatter Plot  library(scatterplot3d) # Generate sample data x <- rnorm(100) y <- rnorm(100) z <- rnorm(100) # Create 3D scatter plot scatterplot3d(x, y, z, main = “3D Scatter Plot”, xlab = “X”, ylab = “Y”, zlab = “Z”) x, y, z: Coordinates for the scatter plot. plotly Package The plotly package provides interactive 3D plotting capabilities. Installation  install.packages(“plotly”) Example: Interactive 3D Plot  library(plotly) # Generate sample data x <- rnorm(100) y <- rnorm(100) z <- rnorm(100) # Create interactive 3D scatter plot plot_ly(x = ~x, y = ~y, z = ~z, type = “scatter3d”, mode = “markers”) type: Type of plot (e.g., “scatter3d”). mode: Plot mode (e.g., “markers” for points). rgl Package The rgl package allows for real-time interactive 3D plots. Installation  install.packages(“rgl”) Example: Interactive 3D Plot with rgl  library(rgl) # Generate sample data x <- rnorm(100) y <- rnorm(100) z <- rnorm(100) # Create interactive 3D scatter plot plot3d(x, y, z, main = “Interactive 3D Scatter Plot”, xlab = “X”, ylab = “Y”, zlab = “Z”) plot3d: Creates an interactive 3D scatter plot. lattice Package The lattice package offers functions for 3D plots, such as cloud(). Installation  install.packages(“lattice”) Example: 3D Scatter Plot with lattice  library(lattice) # Generate sample data x <- rnorm(100) y <- rnorm(100) z <- rnorm(100) # Create 3D scatter plot cloud(z ~ x * y, main = “3D Scatter Plot”, xlab = “X”, ylab = “Y”, zlab = “Z”) z ~ x * y: Formula specifying the plot structure. Customizing 3D Plots Adjusting View Angles In rgl, you can customize the view angle using functions like rgl.viewpoint(). Example: Adjust View Angle  library(rgl) # Generate sample data x <- rnorm(100) y <- rnorm(100) z <- rnorm(100) # Create interactive 3D scatter plot plot3d(x, y, z) # Adjust view angle rgl.viewpoint(theta = 30, phi = 30) Adding Color and Customization You can customize colors and add other features like axes labels, titles, and more in plotly and rgl. Example: Customize 3D Plot with plotly  library(plotly) # Generate sample data x <- rnorm(100) y <- rnorm(100) z <- rnorm(100) # Create interactive 3D scatter plot with customization plot_ly(x = ~x, y = ~y, z = ~z, type = “scatter3d”, mode = “markers”, marker = list(color = ~z, colorscale = “Viridis”)) Summary Base R Functions: Use persp() for surface plots and scatterplot3d for scatter plots. plotly Package: Provides interactive 3D plots with plot_ly(). rgl Package: Allows for real-time interactive 3D plots with plot3d(). lattice Package: Offers 3D plots with cloud(). Customization: Adjust angles, colors, and other features to enhance the visualization.

Closing an R Graphics Device When working with graphics in R, it’s crucial to close the graphics device properly to ensure that your plots are saved correctly and resources are freed. Here’s a detailed overview of how to close an R graphics device. What is a Graphics Device? A graphics device is an interface for creating and displaying graphical output. It could be a window on your screen (for interactive graphics) or a file (such as PDF, PNG, etc.). Closing a Graphics Device To properly close a graphics device, use the dev.off() function. This function completes any pending drawing operations and releases the device, ensuring that the file is saved and any resources are freed. Basic Usage  dev.off()  When to Use After Saving a Plot: When you’ve finished plotting to a file (PDF, PNG, etc.). After Completing Multiple Plots: When you are done with multiple plots in one file. Steps to Close a Graphics Device Open a Graphics Device: Start by opening a graphics device, such as creating a new PDF or PNG file. Example: Open a PDF Device  pdf(“example.pdf”)  # Opens a PDF device plot(1:10, (1:10)^2) Create Your Plot: Generate your plots or graphical output. Example: Plot Data  plot(1:10, (1:10)^2, main = “Plot Example”) Close the Graphics Device: Call dev.off() to close the device and finalize the output. Example: Close the PDF Device  dev.off()  # Closes the PDF device and saves the file  Handling Multiple Devices If you have multiple graphics devices open, dev.off() closes the currently active one. To close a specific device, you can specify its number using dev.set(). Example: Closing a Specific Device  # Open two devices pdf(“first.pdf”) plot(1:10) dev.next()  # Move to the next device png(“second.png”) plot(1:5) # Close the PNG device dev.set(dev.list()[2])  # Set to the second device (PNG) dev.off()  # Close PNG device # Close the PDF device dev.set(dev.list()[1])  # Set to the first device (PDF) dev.off()  # Close PDF device Common Issues and Troubleshooting Error: “No graphics device is active”: This error occurs if dev.off() is called without an active graphics device. Ensure you’ve opened a device before calling dev.off(). Forgotten dev.off(): If you forget to close a graphics device, the file might not be saved properly. Always use dev.off() after plotting to a file. Checking Open Devices To check which devices are currently open, use dev.list(). This function returns a list of open device numbers. Example: List Open Devices  dev.list()  # Lists all open graphics devices Closing All Devices To close all open graphics devices at once, you can use a loop with dev.off(). Example: Close All Devices  while (dev.cur() > 1) dev.off() Summary Open a Device: Use functions like pdf(), png(), etc. Plot Your Data: Create the visualizations you need. Close the Device: Use dev.off() to finalize and save the output. Handle Multiple Devices: Use dev.set() and dev.list() to manage multiple open devices. Troubleshoot: Ensure the device is active before closing and handle errors appropriately.

Saving the Displayed Graph in R Saving your plotted graphs is essential for sharing results and including visuals in reports. Here’s a detailed guide on how to save the displayed graph in R. General Steps for Saving Graphs To save a graph in R, you need to: Open a Graphics Device: Specify the type of file and output settings. Plot the Graph: Use plotting functions like plot(), ggplot(), etc. Close the Graphics Device: Save and close the file. Types of File Formats and Corresponding Functions PDF Creates a PDF file, suitable for printed or digital documents. Example: Save a Graph as a PDF  pdf(“graph.pdf”, width = 8, height = 6)  # Opens a PDF device plot(1:10, (1:10)^2, main = “Example PDF Graph”, xlab = “x”, ylab = “y”) dev.off()  # Closes the device and saves the file width and height: Dimensions of the graph in inches. PNG Creates a PNG file, a raster format ideal for web images and presentations. Example: Save a Graph as a PNG  png(“graph.png”, width = 800, height = 600, res = 100)  # Opens a PNG device plot(1:10, (1:10)^2, main = “Example PNG Graph”, xlab = “x”, ylab = “y”) dev.off()  # Closes the device and saves the file width and height: Dimensions of the graph in pixels. res: Resolution in dots per inch (DPI). JPEG Creates a JPEG file, often used for web images and presentations. Example: Save a Graph as a JPEG  jpeg(“graph.jpeg”, width = 800, height = 600, quality = 90)  # Opens a JPEG device plot(1:10, (1:10)^2, main = “Example JPEG Graph”, xlab = “x”, ylab = “y”) dev.off()  # Closes the device and saves the file quality: Compression quality (0 to 100). TIFF Creates a TIFF file, often used for high-quality images in scientific publications. Example: Save a Graph as a TIFF  tiff(“graph.tiff”, width = 800, height = 600, res = 300)  # Opens a TIFF device plot(1:10, (1:10)^2, main = “Example TIFF Graph”, xlab = “x”, ylab = “y”) dev.off()  # Closes the device and saves the file res: Resolution in DPI. Common Parameters for File Devices width and height: Control the size of the graph. res: Controls the resolution for raster formats (PNG, JPEG, TIFF). bg: Background color of the graph (for raster formats). Advanced Methods for Saving Graphs Multiple Plots in One File To save multiple plots in a single file, use par() to configure the layout. Example: Multiple Plots in a PDF  pdf(“multiple_plots.pdf”) par(mfrow = c(2, 2))  # Layout for 2×2 plots plot(1:10, (1:10)^2, main = “Plot 1”) plot(10:1, (1:10)^2, main = “Plot 2”) plot(1:10, (1:10)^3, main = “Plot 3”) plot((1:10)^2, (1:10)^3, main = “Plot 4”) dev.off() Using ggsave() for ggplot2 If you use ggplot2, the ggsave() function simplifies saving graphs. Example: Save with ggsave()  library(ggplot2) p <- ggplot(mtcars, aes(x = wt, y = mpg)) + geom_point() ggsave(“ggplot_graph.png”, plot = p, width = 8, height = 6, dpi = 100) plot: The graph to save. width and height: Dimensions of the file in inches. dpi: Resolution in DPI. Saving Graphs in R Markdown In R Markdown, graphs are automatically saved in the specified format in the document. Example: R Markdown with Graphs  “`{r} plot(1:10, (1:10)^2, main = “Graph in R Markdown”) Graphs will be saved in the format specified by the options in the R Markdown document.  Summary Open a File Device**: Use `pdf()`, `png()`, `jpeg()`, `tiff()` to specify the format and settings. Plot the Graph**: Use plotting functions like `plot()`, `ggplot()`, etc. Close the Device**: Use `dev.off()` to save and close the file. Customize Settings**: Adjust size, resolution, and background color as needed. Advanced Methods**: Save multiple plots in one file or use `ggsave()` for `ggplot2`.

R Graphics Devices R graphics devices are essential for creating and managing graphical output in R. They allow you to direct your plots to various output formats, such as screens, files, and more. Here’s a detailed guide on R graphics devices. Types of Graphics Devices Screen Devices Screen devices display graphics directly on your monitor. They are interactive and used for on-the-fly visualization. windows() (Windows only): Opens a new graphics window. x11() (Unix-like systems): Opens a new X11 window. quartz() (macOS only): Opens a new graphics window in Quartz. Example: Using windows() windows()  # Opens a new graphics window on Windows plot(1:10, 1:10) File Devices File devices save your plots to files in various formats. You can specify the format using the device function. pdf(): Creates a PDF file. png(): Creates a PNG file. jpeg(): Creates a JPEG file. tiff(): Creates a TIFF file. svg(): Creates an SVG file. Example: Saving a Plot to a PNG File  png(“plot.png”)  # Opens a PNG file device plot(1:10, 1:10)  # Create a plot dev.off()  # Closes the PNG device and saves the file  Common Graphics Device Functions dev.new(): Opens a new graphics window (similar to windows() or x11() but more general). dev.off(): Closes the current graphics device. Always call this after plotting to a file to save and close the file. dev.list(): Lists all open graphics devices. dev.cur(): Returns the number of the current graphics device. Example: Listing and Closing Devices  # List all open devices dev.list() # Close the current device dev.off() Device-Specific Parameters Each graphics device function has parameters that control the output: width and height: Dimensions of the output (in inches for most devices). res: Resolution (for raster devices like PNG and JPEG, in dots per inch). bg: Background color (for raster devices). Example: Creating a High-Resolution PNG  png(“high_res_plot.png”, width = 800, height = 600, res = 150, bg = “white”) plot(1:10, 1:10) dev.off()  Customizing Device Output You can control how plots are rendered on each device: par(): Adjust graphical parameters such as margins, layout, and text size. layout(): Define multiple plots on a single page. mfrow and mfcol: Set up multiple plots in a matrix layout. Example: Multiple Plots in One File  # Save multiple plots to a PDF pdf(“multiple_plots.pdf”) par(mfrow = c(2, 2))  # 2×2 matrix of plots plot(1:10, 1:10) plot(10:1, 1:10) plot(1:10, (1:10)^2) plot((1:10)^2, (1:10)^3) dev.off() Interactive Devices For interactive or real-time graphics, consider using packages like shiny for web applications or rgl for 3D plotting. Example: Using rgl for 3D Plotting  library(rgl) open3d()  # Opens a new 3D plotting window plot3d(rnorm(100), rnorm(100), rnorm(100)) Advanced Use Cases You can combine different devices and save plots in various formats. For instance, generating plots in PNG and then converting them to PDF. Example: Converting PNG to PDF  # Save plot as PNG png(“plot.png”) plot(1:10, 1:10) dev.off() # Convert PNG to PDF using a tool like ImageMagick (from the command line) # convert plot.png plot.pdf  Summary Screen Devices: Use windows(), x11(), or quartz() for on-screen graphics. File Devices: Use pdf(), png(), jpeg(), tiff(), svg() to save plots to files. Device Functions: dev.new(), dev.off(), dev.list(), dev.cur() manage graphics devices. Device Parameters: Control output with parameters like width, height, res, bg. Customizing Output: Use par(), layout(), mfrow, and mfcol for detailed customization. Interactive Devices: Use packages like shiny and rgl for interactive and 3D plots.

Graphing Explicit Functions in R Basic Syntax for Plotting Functions To plot an explicit function in R, you typically use the curve() function, which is specifically designed for plotting mathematical expressions. Here’s the basic syntax:  curve(expr, from = NULL, to = NULL, n = 101, add = FALSE, …) expr: An expression defining the function to plot. from: The starting x-value for the plot (optional). to: The ending x-value for the plot (optional). n: Number of points used to evaluate the function (default is 101). add: Logical value indicating if the curve should be added to an existing plot (default is FALSE). …: Additional graphical parameters (e.g., color, line type). Plotting Basic Functions Example 1: Plotting a Linear Function # Plot a linear function y = 2x + 1 curve(2 * x + 1, from = -10, to = 10, col = “blue”, lwd = 2, main = “Plot of y = 2x + 1”, ylab = “y”, xlab = “x”) 2 * x + 1: The linear function. from = -10: Start x-value. to = 10: End x-value. col = “blue”: Color of the curve. lwd = 2: Line width. Example 2: Plotting a Quadratic Function  # Plot a quadratic function y = x^2 – 4x + 4 curve(x^2 – 4 * x + 4, from = -5, to = 10, col = “red”, lwd = 2, main = “Plot of y = x^2 – 4x + 4”, ylab = “y”, xlab = “x”) x^2 – 4 * x + 4: The quadratic function. Plotting Trigonometric Functions Example 3: Plotting a Sine Function  # Plot a sine function y = sin(x) curve(sin(x), from = -2 * pi, to = 2 * pi, col = “green”, lwd = 2, main = “Plot of y = sin(x)”, ylab = “y”, xlab = “x”) sin(x): The sine function. from = -2 * pi: Start x-value to cover a few periods of the sine wave. to = 2 * pi: End x-value. Example 4: Plotting a Cosine Function  # Plot a cosine function y = cos(x) curve(cos(x), from = -2 * pi, to = 2 * pi, col = “purple”, lwd = 2, main = “Plot of y = cos(x)”, ylab = “y”, xlab = “x”) cos(x): The cosine function. Plotting Exponential and Logarithmic Functions Example 5: Plotting an Exponential Function  # Plot an exponential function y = exp(x) curve(exp(x), from = -2, to = 2, col = “orange”, lwd = 2, main = “Plot of y = exp(x)”, ylab = “y”, xlab = “x”) exp(x): The exponential function. Example 6: Plotting a Logarithmic Function  # Plot a logarithmic function y = log(x) curve(log(x), from = 0.1, to = 10, col = “brown”, lwd = 2, main = “Plot of y = log(x)”, ylab = “y”, xlab = “x”) log(x): The natural logarithm function. from = 0.1: Start x-value to avoid log(0). Customizing the Plot You can customize the plot using graphical parameters: col: Color of the curve. lwd: Line width. lty: Line type (e.g., 1 = solid, 2 = dashed). main: Title of the plot. xlab and ylab: Labels for the x and y axes. Example 7: Customized Plot  # Custom plot with title, axis labels, and different line type curve(x^3 – 3 * x + 1, from = -3, to = 3, col = “blue”, lwd = 2, lty = 3,       main = “Customized Plot of y = x^3 – 3x + 1”,       xlab = “x values”, ylab = “y values”) x^3 – 3 * x + 1: The cubic function. lty = 3: Dashed line type. Adding Multiple Functions to One Plot You can plot multiple functions on the same graph by first creating an empty plot and then adding the curves using curve() with add = TRUE. Example 8: Multiple Functions  # Plot a sine function curve(sin(x), from = -2 * pi, to = 2 * pi, col = “blue”, lwd = 2,       main = “Multiple Functions”, ylab = “y”, xlab = “x”) # Add a cosine function to the existing plot curve(cos(x), from = -2 * pi, to = 2 * pi, col = “red”, lwd = 2, add = TRUE) # Add a legend legend(“topright”, legend = c(“sin(x)”, “cos(x)”), col = c(“blue”, “red”), lwd = 2) add = TRUE: Adds the curve to the existing plot. Advanced Example: Plotting with Conditional Expressions Example 9: Conditional Function  # Plot a piecewise function curve(ifelse(x < 0, x^2, x^3), from = -2, to = 2, col = “green”, lwd = 2,       main = “Piecewise Function”, ylab = “y”, xlab = “x”)  ifelse(x < 0, x^2, x^3): Defines a piecewise function. Summary Basic Syntax: Use curve() to plot explicit functions. expr: Function to plot. from and to: Range of x-values. Basic Examples: Plot linear, quadratic, trigonometric, exponential, and logarithmic functions. Customization: Adjust color, line width, line type, and labels. Multiple Functions: Use add = TRUE to plot multiple functions on the same graph. Conditional Functions: Plot piecewise or conditional functions.