From Equations to Elegance

Crafting Mathematical Art with R

Author

Abhirup Moitra

Published

December 30, 2023

Creating mathematical art in R can be an interesting and creative endeavor. One way to generate mathematical art is by using mathematical functions to determine the position and color of points on a plot. Here’s few example using trigonometric functions:

A Visual Exploration of Trigonometric Patterns

This example uses the parametric equations \(x= \cos(θ)(1+0.5 \cos(7\theta))\) and \(y= \sin(\theta) (1+0.5 \cos(7 \theta))\) to generate a pattern. The geom_line function is then used to connect the points.

# Install and load the ggplot2 package
#install.packages("tidyverse")
library(tidyverse)

# Function to draw mathematical art
drawMathematicalArt <- function() {
  theta <- seq(0, 2 * pi, length.out = 1000)
  
  # Define mathematical functions to determine x and y coordinates
  x <- cos(theta) * (1 + 0.5 * cos(7 * theta))
  y <- sin(theta) * (1 + 0.5 * cos(7 * theta))
  
  # Create a data frame with x and y coordinates
  art_data <- data.frame(x, y)
  
  ggplot(art_data, aes(x, y)) +
    geom_line(color = "blue") +
    theme_void()
}

# Call the function to draw the mathematical art
drawMathematicalArt()

Critical Analysis of Code

Install and Load Tidyverse:

install.packages("tidyverse")
library(tidyverse)

This code installs the tidyverse package if it’s not already installed and then loads it into the current R session. The tidyverse is a collection of R packages designed for data science and includes popular packages like ggplot2, dplyr, tidyr, etc.

Function Definition:

drawMathematicalArt <- function() {
  # Function body
}

This code defines a function named drawMathematicalArt. The function does not take any arguments.

Generate Theta Values:

theta <- seq(0, 2 * pi, length.out = 1000)

This line generates a sequence of \(1000\) values for the variable theta ranging from \(0\) to \(2 \pi\).

Define Mathematical Functions for Coordinates:

x <- cos(theta) * (1 + 0.5 * cos(7 * theta))
y <- sin(theta) * (1 + 0.5 * cos(7 * theta))

These lines define mathematical functions to determine the x and y coordinates based on the generated values of theta. The equations used here create a mathematical pattern.

Create Data Frame:

art_data <- data.frame(x, y)

This line creates a data frame named art_data with columns ‘x’ and ‘y’ using the previously calculated coordinates.

Plot Using `ggplot2()`:

ggplot(art_data, aes(x, y)) +
  geom_line(color = "blue") +
  theme_void()

This code uses ggplot2 to create a line plot of the data in art_data. It specifies the x and y aesthetics and uses a blue color for the line. The theme_void() function is used to remove any axes and labels, leaving only the plotted line.

Call the Function:

drawMathematicalArt()

Finally, this line calls the drawMathematicalArt function, which executes the code within the function and produces the mathematical art plot.

In summary, the provided code generates a beautiful mathematical art plot using trigonometric functions and the ggplot2 package. The pattern is created by manipulating polar coordinates and then visualized using a line plot.

Creating Mesmerizing Pattern

In this example, we used a combination of trigonometric functions to create a more intricate pattern. Feel free to experiment with different mathematical functions, adjust parameters, or combine multiple functions to create your unique mathematical art. The possibilities are vast, and you can achieve a wide range of interesting visual effects by exploring various mathematical expressions.

# Function to draw complex mathematical art
drawComplexMathArt <- function() {
  t <- seq(0, 2 * pi, length.out = 1000)
  
  # Define mathematical functions to determine x and y coordinates
  x <- sin(16 * t) * sin(t)^3
  y <- cos(13 * t) - cos(5 * t) - cos(2 * t) - cos(3 * t)
  
  # Create a data frame with x and y coordinates
  art_data <- data.frame(x, y)
  
  ggplot(art_data, aes(x, y)) +
    geom_line(color = "purple", size = 1) +
    theme_void()
}

# Call the function to draw the complex mathematical art
drawComplexMathArt()

Warning: Using `size` aesthetic for lines was deprecated in ggplot2 3.4.0.
ℹ Please use `linewidth` instead.

This R code defines a function called drawComplexMathArt that generates a plot of a complex mathematical pattern. Let’s break down the code and provide a critical analysis:

Critical Analysis of Code

Parameter-less Function:

drawComplexMathArt <- function(){

# Function Body

}

The function is defined without any parameters, indicating that it relies on internal calculations and doesn’t take any external inputs.

Time Vector:

t <- seq(0, 2 * pi, length.out = 1000)

It creates a time vector t ranging from \(0\) to \(2\pi\) with \(1000\) points. This vector is then used to calculate the x and y coordinates.

Coordinate Calculations:

x <- sin(16 * t) * sin(t)^3
y <- cos(13 * t) - cos(5 * t) - cos(2 * t) - cos(3 * t)

The x and y coordinates are calculated based on mathematical functions involving trigonometric operations. The resulting values form the shape of the mathematical art.

Data Frame Creation:

art_data <- data.frame(x, y)

The x and y coordinates are combined into a data frame named art_data.

Plotting with `ggplot2()`:

ggplot(art_data, aes(x, y)) +
  geom_line(color = "purple", size = 1) +
  theme_void()

The ggplot2 package is used to create a line plot using the x and y coordinates. The line color is set to purple, and the line size is set to 1. The theme_void() function is used to create a plot with a blank background.

Function Call:

drawComplexMathArt()

More Analysis

Readability and Documentation: The code is relatively clear and well-organized. However, it lacks comments and documentation, which would be beneficial for understanding the purpose and mathematical details of the pattern.
Magic Numbers: The numbers used in the trigonometric calculations (e.g., 16, 13, 5, 2, 3) are considered “magic numbers” as they lack explanation. Adding comments explaining the significance of these numbers would enhance the code’s readability.
Function Design: The function design is good for creating reusable code. However, adding parameters to allow customization of the plot, such as the number of points or colors, could make it more versatile.
Plot Aesthetics: The aesthetics of the plot, such as color and size, are subjective. Users may want to customize these aspects based on their preferences.
Error Handling: The code assumes that the ggplot2 package is installed and loaded. Including error handling for cases where the package is not available would be a good practice.

In summary, the code generates an interesting mathematical art plot using trigonometric functions. Improvements could be made in terms of documentation, parameterization for customization, and handling potential errors.

Simplified Butterfly Plot

The code defines a function that uses mathematical functions to generate coordinates for a butterfly plot and then uses ggplot2() to visualize it. The butterfly plot is displayed as a blue line on a blank background. The step-by-step breakdown helps us understand how the code progresses from generating coordinates to creating a plot.

# Function to draw a simplified butterfly plot
drawButterfly <- function() {
  t <- seq(0, 2 * pi, length.out = 1000)
  
  # Define mathematical functions to determine x and y coordinates
  x_left <- 2 * sin(t) * (exp(cos(t)) - 2 * cos(4 * t) - sin(t/12)^5)
  y_left <- 2 * cos(t) * (exp(cos(t)) - 2 * cos(4 * t) - sin(t/12)^5)
  
  x_right <- -x_left
  y_right <- y_left
  
  # Create a data frame with x and y coordinates
  butterfly_data <- data.frame(x = c(x_left, x_right), y = c(y_left, y_right))
  
  ggplot(butterfly_data, aes(x, y)) +
    geom_line(color = "blue", size = 1) +
    theme_void()
}

# Call the function to draw the butterfly plot
drawButterfly()

Critical Analysis of Code

Function Definition:

drawButterfly <- function() {

# Function Body 

}

Defines a function named drawButterfly.

Generate Time Values

  t <- seq(0, 2 * pi, length.out = 1000)

Generates a sequence of \(1000\) values ranging from \(0\) to \(2\pi\) (a full circle) and stores it in the variable t. These values will be used as parameters for the mathematical functions.

Define Left Wing Coordinates

x_left <- 2 * sin(t) * (exp(cos(t)) - 2 * cos(4 * t) - sin(t/12)^5)
y_left <- 2 * cos(t) * (exp(cos(t)) - 2 * cos(4 * t) - sin(t/12)^5)

Computes the x and y coordinates for the left wing of the butterfly using trigonometric and exponential functions.

Mirror Left Wing to Create Right Wing

x_right <- -x_left
y_right <- y_left

Creates the right wing by mirroring the x coordinates of the left wing and keeping the y coordinates the same.

Create Data Frame

butterfly_data <- data.frame(x = c(x_left, x_right), y = c(y_left, y_right))

Combines the left and right wing coordinates into a data frame named butterfly_data with columns ‘x’ and ‘y’.

Plotting with `ggplot2()`:

  ggplot(butterfly_data, aes(x, y)) +
    geom_line(color = "blue", size = 1) +
    theme_void()

Uses ggplot2 to create a line plot using the x and y coordinates from butterfly_data.
geom_line specifies a blue line with a size of 1.
theme_void() removes unnecessary axis labels and grid lines.

Function Invocation

drawButterfly()

Calls the drawButterfly function to generate and display the butterfly plot.

Summary

The code defines a function that uses mathematical functions to generate coordinates for a butterfly plot and then uses ggplot2 to visualize it. The butterfly plot is displayed as a blue line on a blank background. The step-by-step breakdown helps understand how the code progresses from generating coordinates to creating a plot.

This R code defines a function butterfly_curve that generates x and y coordinates for a butterfly curve using a given set of timestamps.

# Define the butterfly_curve function
butterfly_curve <- function(timestamps) {
  x <- numeric(length(timestamps))
  y <- numeric(length(timestamps))
  
  for (k in seq_along(timestamps)) {
    x[k] <- sin(timestamps[k]) * (exp(cos(timestamps[k])) - 2 * cos(4 * timestamps[k]) - (sin(timestamps[k]/12))^5)
    y[k] <- cos(timestamps[k]) * (exp(cos(timestamps[k])) - 2 * cos(4 * timestamps[k]) - (sin(timestamps[k]/12))^5)
  }
  
  return(data.frame(x = x, y = y))
}

# Generate timestamps
time <- seq(0, 12 * pi, by = 0.01)

# Create butterfly curve data
butterfly_data <- butterfly_curve(time)

# Create a plot using ggplot2
ggplot(butterfly_data, aes(x, y)) +
  geom_line(color = "blue") +
  labs(x = "x", y = "y", title = "Butterfly Curve") +
  theme_minimal() +
  theme(panel.grid = element_blank()) +
  geom_hline(yintercept = 0, color = "black") +
  geom_vline(xintercept = 0, color = "black")

It then creates a butterfly curve using ggplot2. Here’s a step-by-step analysis:

Critical Analysis

Function Definition: `butterfly_curve`

butterfly_curve <- function(timestamps) {
  x <- numeric(length(timestamps))
  y <- numeric(length(timestamps))
  
  for (k in seq_along(timestamps)) {
    x[k] <- sin(timestamps[k]) * (exp(cos(timestamps[k])) - 2 * cos(4 * timestamps[k]) - (sin(timestamps[k]/12))^5)
    y[k] <- cos(timestamps[k]) * (exp(cos(timestamps[k])) - 2 * cos(4 * timestamps[k]) - (sin(timestamps[k]/12))^5)
  }
  
  return(data.frame(x = x, y = y))
}

The function butterfly_curve takes a vector of timestamps as input and computes x and y coordinates for each timestamp based on mathematical functions.
It uses a loop to iterate over each timestamp and compute corresponding x and y values.
The function returns a data frame containing the x and y coordinates.

Generate Timestamps

time <- seq(0, 12 * pi, by = 0.01)

Generates a sequence of timestamps from \(0\) to \(12\pi\) with a step size of \(0.01\).

Create Butterfly Curve Data

butterfly_data <- butterfly_curve(time)

Calls the butterfly_curve function to generate a data frame (butterfly_data) with x and y coordinates for the butterfly curve.

Create ggplot2 Plot

ggplot(butterfly_data, aes(x, y)) +
  geom_line(color = "blue") +
  labs(x = "x", y = "y", title = "Butterfly Curve") +
  theme_minimal() +
  theme(panel.grid = element_blank()) +
  geom_hline(yintercept = 0, color = "black") +
  geom_vline(xintercept = 0, color = "black")

Uses ggplot2 to create a line plot of the butterfly curve using the x and y coordinates from butterfly_data.
labs is used to set axis labels and the plot title.
theme_minimal provides a clean and minimalistic plot style.
geom_hline and geom_vline add horizontal and vertical lines to represent the x and y axes.

Summary

This code generates a butterfly curve using mathematical functions, visualizes it with ggplot2, and adds some customization to the plot. The resulting plot displays the butterfly curve with clear axis labels and a minimalistic design.

The key difference between the two sets of code is the structure and usage. Here are the main distinctions:

1. Function vs. No Function:

Previous Code: The first set of codes defines a reusable function drawButterfly that encapsulates the logic for generating the butterfly plot. The function is then called to produce the plot.
Current Code: The second set of code defines a function butterfly_curve for generating butterfly curve coordinates but doesn’t encapsulate the code for plotting. Instead, it directly uses ggplot2 to create the plot.

2. Timestamps Handling:

Previous Code: The first code snippet internally generates timestamps (t) within the drawButterfly function.
Current Code: The second code snippet expects timestamps (time) to be generated externally before calling the butterfly_curve function.

3. Plot Customization:

Previous Code: The first code snippet creates a butterfly plot with a blue line on a void background.
Current Code: The second code snippet creates a butterfly plot with a blue line on a minimalistic background, adds axis labels, and includes horizontal and vertical lines representing the axes.

4. Data Handling:

Previous Code: The first code snippet directly creates a data frame (butterfly_data) within the drawButterfly function.
Current Code: The second code snippet separates the data generation (butterfly_curve) from the plotting, allowing for flexibility in using the butterfly curve data for other purposes.

5. Code Organization:

Previous Code: The first code snippet has a function that encapsulates the entire process of generating and plotting the butterfly plot.
Current Code: The second code snippet has a function for generating butterfly curve coordinates, and the plot creation and customization are done outside the function.

Summary:

Both sets of code achieve the common goal of generating a butterfly plot using similar mathematical functions. The differences lie in code organization, reusability, and whether the code is encapsulated within a function. The second set of code offers more flexibility by separating data generation from plotting, allowing for easier reuse of the butterfly curve data for different visualizations or analyses.

Remarks

Choosing between Python and R for a specific task, like plotting a butterfly curve in this case, depends on various factors. Here are some considerations and potential benefits of using Python over R in this context:

Ecosystem and Libraries:
- Python has a rich ecosystem with libraries like NumPy, SciPy, and Matplotlib, which are widely used for numerical computing and data visualization. These libraries provide efficient tools for mathematical operations and plotting, making it convenient for tasks like generating butterfly curves.
Versatility:
- Python is a general-purpose programming language with a broad range of applications beyond statistical analysis and data visualization. If your project involves diverse tasks or integration with other tools and technologies, Python’s versatility might be an advantage.
Syntax and Readability:
- Some developers find Python syntax to be more readable and expressive. It often adheres to the principle of readability, making it easier to understand and maintain code.
Community and Resources:
- Python has a large and active community, resulting in extensive documentation, tutorials, and resources. If you encounter issues or need assistance, you’re likely to find more support and solutions.
Integration with Other Tools:
- Python integrates well with a variety of tools and technologies. If your project involves connecting to databases, working with web frameworks, or integrating with machine learning libraries, Python may provide better support and compatibility.
Machine Learning and Data Science:
- Python has become a popular language for machine learning and data science, with widely used libraries such as TensorFlow, PyTorch, and scikit-learn. If your project extends beyond plotting to include machine learning or data analysis, Python might be a more natural choice.
Personal Preference and Familiarity:
- Your familiarity and comfort with a particular language can significantly impact your productivity. If you are more experienced or comfortable with Python, it may be the preferred choice.
Development Environment:
- Python offers a flexible and powerful development environment with popular IDEs (Integrated Development Environments) like Jupyter Notebooks, VS Code, and PyCharm. This can contribute to a positive development experience.

It’s essential to note that both Python and R are capable of generating butterfly curves, and the choice between them often comes down to personal preference, existing project requirements, and the specific strengths of each language within the context of your work.

import numpy as np
import matplotlib.pyplot as plt

def butterfly_curve(timestamps):
    x = np.sin(timestamps) * (np.exp(np.cos(timestamps)) - 2 * np.cos(4 * timestamps) - (np.sin((timestamps/12))**5))
    y = np.cos(timestamps) * (np.exp(np.cos(timestamps)) - 2 * np.cos(4 * timestamps) - (np.sin((timestamps/12))**5))
    
    return x, y

time = np.arange(0, 12 * np.pi, 0.01)
plt.plot(butterfly_curve(time)[0], butterfly_curve(time)[1], color='blue', linewidth=1.5)
plt.title('Butterfly Curve')
plt.xlabel('x')
plt.ylabel('y')
plt.axhline(0, color='black')
plt.axvline(0, color='black')
plt.show()

Analysis Report: Butterfly Curve Plotting

Conciseness and Readability:
- The code is concise and easy to read, leveraging NumPy for efficient mathematical operations.
- The function butterfly_curve encapsulates the logic for calculating the butterfly curve coordinates.
Plotting and Visualization:
- Matplotlib is used for plotting the butterfly curve with a clear and concise syntax.
- The plot is well-customized with a blue line, appropriate title, and axis labels for clarity.
Efficiency:
- NumPy’s array operations are utilized for vectorized calculations, enhancing computational efficiency.
- The use of vectorized operations makes the code more readable and potentially faster than using explicit loops.
Plot Customization:
- The plot is appropriately customized with a title, axis labels, and axes lines, improving interpretability.
Code Structure:
- The code is well-structured, with a clear separation of the function for generating butterfly curve coordinates and the code for plotting.
Readability and Clarity:
- Variable names are clear and provide good readability.
- The use of NumPy functions aligns with standard conventions, contributing to clarity.
Flexibility:
- The code is adaptable, allowing for easy modification of parameters or integration into other projects.
Overall Impression:
- The code effectively achieves its goal of generating and visualizing a butterfly curve.
- It strikes a balance between conciseness, readability, and efficiency.
Suggestions for Improvement:
- Consider storing the result of butterfly_curve(time) in a variable to avoid redundant calculations.
- Encapsulation of the entire process within a function could enhance reusability.

In summary, the provided Python code is well-written, efficiently generates butterfly curve coordinates, and produces a clear and visually appealing plot using Matplotlib.

Dance of Equations

# Generate theta values
theta <- seq(0, 2 * pi, length.out = 1000)

# Define mathematical functions for r1 and r2
r1 <- 1 + 0.5 * sin(8 * theta)
r2 <- 0.5 + 0.3 * cos(12 * theta)

# Convert polar coordinates to Cartesian coordinates
x1 <- r1 * cos(theta)
y1 <- r1 * sin(theta)

x2 <- r2 * cos(theta)
y2 <- r2 * sin(theta)

# Create a data frame with x, y coordinates for two functions
math_art_data <- data.frame(x1 = x1, y1 = y1, x2 = x2, y2 = y2)

# Create a plot using ggplot2
ggplot(math_art_data, aes(x = x1, y = y1)) +
  geom_line(color = "blue", size = 1) +
  geom_line(aes(x = x2, y = y2), color = "red", size = 1) +
  labs(title = "Math Art", x = NULL, y = NULL) +
  theme_minimal()

This R code generates mathematical art by defining two functions in polar coordinates and converting them to Cartesian coordinates. Here’s a brief analysis of the code:

Generate Theta Values:
- Creates a sequence of theta values ranging from 0 to \(2\pi\) with \(1000\) points.
Define Mathematical Functions (Polar Coordinates):
- \(r_1=1+0.5 \sin(8\theta)\)
- \(r_2=0.5+0.3 \cos(12\theta)\)
- These functions determine the radial distance from the origin for each point in polar coordinates.
Convert to Cartesian Coordinates:
- Converts polar coordinates to Cartesian coordinates for both functions.
Create Data Frame:
- Combines the Cartesian coordinates of both functions into a data frame (math_art_data) with columns for \(x_1,y_1,x_2,y_2\).
Create ggplot2 Plot:
- Uses ggplot2 to create a line plot with two lines.
- The first line (geom_line) is in blue and represents the points defined by \(x_1,y_1.\)
- The second line is in red and represents the points defined by \(x_2,y_2.\)
Plot Customization:
- Sets the title to “Math Art” and removes axis labels (x = NULL, y = NULL).
- Applies a minimal theme (theme_minimal()).

Summary:

The code effectively creates a visually interesting mathematical art plot using ggplot2 in R. It combines two functions in polar coordinates, converts them to Cartesian coordinates, and plots them with distinct colors. The use of ggplot2 allows for easy customization and visualization of the mathematical art.

A Visual Exploration of Trigonometric Patterns

Critical Analysis of Code

Install and Load Tidyverse:

Function Definition:

Generate Theta Values:

Define Mathematical Functions for Coordinates:

Create Data Frame:

Plot Using ggplot2():

Call the Function:

Creating Mesmerizing Pattern

Critical Analysis of Code

Parameter-less Function:

Time Vector:

Coordinate Calculations:

Data Frame Creation:

Plotting with ggplot2():

Function Call:

More Analysis

Simplified Butterfly Plot

Critical Analysis of Code

Function Definition:

Generate Time Values

Define Left Wing Coordinates

Mirror Left Wing to Create Right Wing

Create Data Frame

Plotting with ggplot2():

Function Invocation

Summary

Critical Analysis

Function Definition: butterfly_curve

Generate Timestamps

Create Butterfly Curve Data

Create ggplot2 Plot

Summary

1. Function vs. No Function:

2. Timestamps Handling:

3. Plot Customization:

4. Data Handling:

5. Code Organization:

Summary:

Remarks

Dance of Equations

Summary:

Plot Using `ggplot2()`:

Plotting with `ggplot2()`:

Plotting with `ggplot2()`:

Function Definition: `butterfly_curve`