Prime Numbers
https://www.desmos.com/calculator/oweber0ane
In this experiment, I align an edge of every possible shape and observe that each shape is composed of an integer multiple of prime numbers. By arranging these shapes around a circle using integer points, a multiplication 'table' of sorts emerges. This visual representation provides insight into the fundamental relationship between prime numbers and circles.
The primary goal of this experiment is to explore and understand the relationship between prime numbers and circles. Through the use of visual aids, we can gain new insights into the underlying structure of these mathematical concepts. By identifying and analyzing patterns in the multiplication table of shapes around the circle, we can better understand the ways in which prime numbers and circles are connected.
MATLAB Code:
clear; clc; close all; % Clear variables, windows, and command window
n = 50; % Set number of circles
temp = zeros(n,n); % Create an empty square matrix to fill with corner data
figure % Make a new figure
hold on % Plot everything on a single plot unless stated otherwise
for i = 1:n % Loop from 1 to n
temp(i,1:i) = wheel(i); % Gather the wheel data starting at 0
% % % % rectangle('Position',[-1 -1 2 2]*i ,'Curvature',[1 1]) % Draw the circles
plot([real(temp(i,1:i)) i],[imag(temp(i,1:i)) 0]); % Draw the shapes
end
plot(real(temp),imag(temp),'ok','Markersize',1,'MarkerFaceColor','r') % Draw the corner points
grid on % turn on the grid
axis equal % Make the data aspect ratio equal
set(gca,'YLim',[-1 1]*n*1.1) % Make the y-limit 10% greater than the largest shape
clear temp % clear the temp data to fill it with prime number data
n = 10; % Number of primes
load('primes.mat'); % Import prime number database
primessection = primes(1:n)'; % Grab the first n primes
temp = zeros(n,primessection(end)); % create an empty rectangle matrix
figure % Create a new figure
hold on % Hold onto that single figure
for i = 1:n % begin a for loop for the number of prime numbers
temp(i,1:primessection(i)) = wheel(primessection(i)); % Create the prime number wheel
plot([real(temp(i,1:primessection(i))) primessection(i)],[imag(temp(i,1:primessection(i))) 0]); % Draw the prime number wheel
end
plot(real(temp),imag(temp),'ok','Markersize',1,'MarkerFaceColor','r') % plot the edges of the shape
grid on % Turn on the grid
axis equal % Enable the aspect ratio
set(gca,'YLim',[-1 1]*primessection(end)*1.1) % set the limits to 10% more than the end
Description:
This MATLAB code creates visual representations of circles and prime number wheels using a matrix of corner data.
The code begins by clearing all variables and creating an empty square matrix called "temp" with dimensions (n,n), where n is set to 50.
The program then creates a new figure and sets the "hold on" property, which allows subsequent plots to be overlaid on the same figure.
Next, a for loop is initiated to loop from 1 to n. Within the loop, the "wheel" function is called with i as the input to gather the wheel data starting at 0. The wheel data is then assigned to the first i columns of row i of the "temp" matrix.
The shapes formed by the circles are then plotted by calling the "plot" function with the real and imaginary parts of the data in the "temp" matrix as inputs.
After plotting the circle shapes, the corner points of the matrix are plotted in red. The grid is turned on, and the data aspect ratio is set to equal. The y-limit is also set to be 10% greater than the largest shape.
The code then proceeds to create a new figure and matrix called "temp" with dimensions (n,primessection(end)), where n is set to 10. The program then imports a database of prime numbers using the "load" function and selects the first n prime numbers.
The program then enters another for loop to loop from 1 to n. Within the loop, the "wheel" function is called with primessection(i) as the input to create a prime number wheel. The prime number wheel is then assigned to the first primessection(i) columns of row i of the "temp" matrix.
The prime number wheels are then plotted using the "plot" function. Finally, the edges of the shape are plotted in red, the grid is turned on, and the data aspect ratio is set to equal. The y-limit is also set to be 10% greater than the largest shape.
Overall, this code uses the "wheel" function to create shapes based on the properties of circles and prime numbers, and plots them using the "plot" function. The resulting visualizations provide insight into the relationship between circles and prime numbers.
MATLAB Wheel Function:
function y = wheel(Dots)
%WHEEL creates a circle with the specified number of dots
% y = wheel(10)
% returns 10 outputs around a circle from 0 to 9 spaces
y = Dots*exp(-1j*(0:Dots-1)/Dots*2*pi);
end
The code defines a MATLAB function called "wheel" that takes an input argument "Dots", which is an integer representing the number of dots to place around a circle. The function returns a vector "y" containing complex numbers that represent the positions of the dots on the circle.
The function uses the MATLAB "exp" function to compute a complex exponential with a phase that varies linearly with the index of each dot. Specifically, it computes the complex number exp(-1j*(0:Dots-1)/Dots2pi), where 1j is the imaginary unit and 2*pi is the angle of a full circle. The resulting complex numbers are evenly spaced around the unit circle and are multiplied by the scalar value "Dots" to scale the circle to the desired size.
Thus, calling the function with an input argument of 10, for example, would return a vector of 10 complex numbers that represent the positions of 10 equally spaced dots around a circle.
All Shapes From 1 to 50
This image shows a progression of 50 shapes formed by dots placed around a circle, ranging from simple to complex. The shapes are arranged in a grid and composed of repeating patterns of lines and curves, showcasing the versatility and intricacy of the dot patterns.
First Ten Prime Numbers
This image represents the first 10 prime numbers displayed as shapes made of dots arranged around a circle. The shapes, ranging from simple to complex, reveal the patterns inherent in each prime number and showcase the beauty and complexity of prime numbers in a new and creative way.
Edit function to compress the prime circles:
First ten prime numbers (scaled to nth P)
This image displays the first 10 prime numbers using a unique visual representation, where each prime is shown as a shape constructed from dots placed around a circle. The circle is scaled according to the value of the prime number, resulting in smaller circles for smaller primes and larger circles for larger primes, allowing the viewer to better appreciate the unique patterns and structures inherent in each prime number.
MATLAB function:
clear; clc; close all;
n = 50;
temp = zeros(n,n);
figure
hold on
for i = 1:n
% Gather the wheel data starting at 0
temp(i,1:i) = i*wheel(i); % Added multiple of i since its removed from wheels
% % % % % Draw the circles
% % % % rectangle('Position',[-1 -1 2 2]*i ,'Curvature',[1 1])
% Draw the shapes
plot([real(temp(i,1:i)) i],[imag(temp(i,1:i)) 0]);
end
plot(real(temp),imag(temp),'ok','Markersize',1,'MarkerFaceColor','r')
grid on
axis equal
set(gca,'YLim',[-1 1]*n*1.1)
%% Prime Number section
clear temp
n = 10;
load('primes.mat');
primessection = primes(1:n)';
temp = zeros(n,primessection(end));
figure
hold on
for i = 1:n
temp(i,1:primessection(i)) = i*wheel(primessection(i)); % Added multiple of the wheel with respect to the loop
% Draw the shapes
plot([real(temp(i,1:primessection(i))) i],[imag(temp(i,1:primessection(i))) 0]); % swapped the last x value from primessection(i) to i
end
plot(real(temp),imag(temp),'ok','Markersize',1,'MarkerFaceColor','r')
grid on
axis equal
set(gca,'YLim',[-1 1]*n*1.1) % Changed the limit to be the nth prime
Description
This is a modified version of the previous code, where each wheel of dots is rescaled by a multiple of i in the loop, resulting in a spiral-like pattern with dots moving further away from the center as i increases. The second section of the code shows the first 10 prime numbers as spirals that also scale based on the value of i, with the i-th prime number wheel having i times the size of a regular prime number wheel.
Wheel
function y = wheel(Dots)
%WHEEL creates a circle with the specified number of dots
% y = wheel(10)
% returns 10 outputs around a circle from 0 to 9 spaces
y = exp(-1j*(0:Dots-1)/Dots*2*pi); % Removed the multiple of the number of points ('Dots')
end
Description
This code defines a function called "wheel" that creates a complex-valued vector representing a circle with a specified number of points or "dots". The vector is created by dividing the circumference of the circle into equally spaced points and then using the exponential function to map each point to a point on the unit circle. The output "y" is a row vector of length "Dots" with each element representing a point on the unit circle. The difference between this code and the previous one is that here the multiple of the number of points is removed, resulting in the output vector having a unit radius.
Overlap first fifty prime numbers on MATLAB
The image represents the overlap of the first fifty prime numbers on MATLAB. It is worth noting that the arclength between each point around the circle approximates to 2*pi.
The code and images provided on this website are for educational purposes only. The author is not responsible for any damages or losses arising from the use or misuse of this code or these images. All code and images are provided as-is, with no warranty or guarantee of any kind. Use at your own risk.