Are you local to Boston?

Shape the Future of MATLAB: Join MathWorks' UX Night In-Person!

When: June 25th, 6 to 8 PM

Where: MathWorks Campus in Natick, MA

🌟 Calling All MATLAB Users! Here's your unique chance to influence the next wave of innovations in MATLAB and engineering software. MathWorks invites you to participate in our special after-hours usability studies. Dive deep into the latest MATLAB features, share your valuable feedback, and help us refine our solutions to better meet your needs.

🚀 This Opportunity Is Not to Be Missed:

- Exclusive Hands-On Experience: Be among the first to explore new MATLAB features and capabilities.
- Voice Your Expertise: Share your insights and suggestions directly with MathWorks developers.
- Learn, Discover, and Grow: Expand your MATLAB knowledge and skills through firsthand experience with unreleased features.
- Network Over Dinner: Enjoy a complimentary dinner with fellow MATLAB enthusiasts and the MathWorks team. It's a perfect opportunity to connect, share experiences, and network after work.
- Earn Rewards: Participants will not only contribute to the advancement of MATLAB but will also be compensated for their time. Plus, enjoy special MathWorks swag as a token of our appreciation!

👉 Reserve Your Spot Now: Space is limited for these after-hours sessions. If you're passionate about MATLAB and eager to contribute to its development, we'd love to hear from you.

Hello and a warm welcome to all! We're thrilled to have you visit our community. MATLAB Central is a place for learning, sharing, and connecting with others who share your passion for MATLAB and Simulink. To ensure you have the best experience, here are some tips to get you started:

- Read the Community Guidelines: Understanding our community standards is crucial. Please take a moment to familiarize yourself with them. Keep in mind that posts not adhering to these guidelines may be flagged by moderators or other community members.
- Ask Technical Questions at MATLAB Answers: If you have questions related to MathWorks products, head over to MATLAB Answers (new question form - Ask the community). It's the go-to spot for technical inquiries, with responses often provided within an hour, depending on the complexity of the question and volunteer availability. To increase your chances of a speedy reply, check out our tips on how to craft a good question (link to post on asking good questions).
- Choosing the Right Channel: We offer a variety of discussion channels tailored to different contexts. Select the one that best fits your post. If you're unsure, the General channel is always a safe bet. If you feel there's a need for a new channel, we encourage you to suggest it in the Ideas channel.
- Reporting Issues: If you encounter posts that violate our guidelines, please use the 🚩Flag/Report feature (found in the 3-dot menu) to bring them to our attention.
- Quality Control: We strive to maintain a high standard of discussion. Accounts that post spam or too much nonsense may be subject to moderation, which can include temporary suspensions or permanent bans.
- Share Your Ideas: Your feedback is invaluable. If you have suggestions on how we can improve the community or MathWorks products, the Ideas channel is the perfect place to voice your thoughts.

Enjoy yourself and have fun! We're committed to fostering a supportive and educational environment. Dive into discussions, share your expertise, and grow your knowledge. We're excited to see what you'll contribute to the community!

📚 New Book Announcement: "Image Processing Recipes in MATLAB" 📚

I am delighted to share the release of my latest book, "Image Processing Recipes in MATLAB," co-authored by my dear friend and colleague Gustavo Benvenutti Borba.

This 'cookbook' contains 30 practical recipes for image processing, ranging from foundational techniques to recently published algorithms. It serves as a concise and readable reference for quickly and efficiently deploying image processing pipelines in MATLAB.

Gustavo and I are immensely grateful to the MathWorks Book Program for their support. We also want to thank Randi Slack and her fantastic team at CRC Press for their patience, expertise, and professionalism throughout the process.

___________

Are you a Simulink user eager to learn how to create apps with App Designer? Or an App Designer enthusiast looking to dive into Simulink?

Don't miss today's article on the Graphics and App Building Blog by @Robert Philbrick! Discover how to build Simulink Apps with App Designer, streamlining control of your simulations!

Hi to all.

I'm trying to learn a bit about trading with cryptovalues. At the moment I'm using Freqtrade (in dry-run mode of course) for automatic trading. The tool is written in python and it allows to create custom strategies in python classes and then run them.

I've written some strategy just to learn how to do, but now I'd like to create some interesting algorithm. I've a matlab license, and I'd like to know what are suggested tollboxes for following work:

- Create a criptocurrency strategy algorythm (for buying and selling some crypto like BTC, ETH etc).
- Backtesting the strategy with historical data (I've a bunch of json files with different timeframes, downloaded with freqtrade from binance).
- Optimize the strategy given some parameters (they can be numeric, like ROI, some kind of enumeration, like "selltype" and so on).
- Convert the strategy algorithm in python, so I can use it with Freqtrade without worrying of manually copying formulas and parameters that's error prone.
- I'd like to write both classic algorithm and some deep neural one, that try to find best strategy with little neural network (they should run on my pc with 32gb of ram and a 3080RTX if it can be gpu accelerated).

What do you suggest?

The study of the dynamics of the discrete Klein - Gordon equation (DKG) with friction is given by the equation :

above equation, W describes the potential function :

The objective of this simulation is to model the dynamics of a segment of DNA under thermal fluctuations with fixed boundaries using a modified discrete Klein-Gordon equation. The model incorporates elasticity, nonlinearity, and damping to provide insights into the mechanical behavior of DNA under various conditions.

% Parameters

numBases = 200; % Number of base pairs, representing a segment of DNA

kappa = 0.1; % Elasticity constant

omegaD = 0.2; % Frequency term

beta = 0.05; % Nonlinearity coefficient

delta = 0.01; % Damping coefficient

- Position: Random initial perturbations between 0.01 and 0.02 to simulate the thermal fluctuations at the start.
- Velocity: All bases start from rest, assuming no initial movement except for the thermal perturbations.

% Random initial perturbations to simulate thermal fluctuations

initialPositions = 0.01 + (0.02-0.01).*rand(numBases,1);

initialVelocities = zeros(numBases,1); % Assuming initial rest state

The simulation uses fixed ends to model the DNA segment being anchored at both ends, which is typical in experimental setups for studying DNA mechanics. The equations of motion for each base are derived from a modified discrete Klein-Gordon equation with the inclusion of damping:

% Define the differential equations

dt = 0.05; % Time step

tmax = 50; % Maximum time

tspan = 0:dt:tmax; % Time vector

x = zeros(numBases, length(tspan)); % Displacement matrix

x(:,1) = initialPositions; % Initial positions

% Velocity-Verlet algorithm for numerical integration

for i = 2:length(tspan)

% Compute acceleration for internal bases

acceleration = zeros(numBases,1);

for n = 2:numBases-1

acceleration(n) = kappa * (x(n+1, i-1) - 2 * x(n, i-1) + x(n-1, i-1)) ...

- delta * initialVelocities(n) - omegaD^2 * (x(n, i-1) - beta * x(n, i-1)^3);

end

% positions for internal bases

x(2:numBases-1, i) = x(2:numBases-1, i-1) + dt * initialVelocities(2:numBases-1) ...

+ 0.5 * dt^2 * acceleration(2:numBases-1);

% velocities using new accelerations

newAcceleration = zeros(numBases,1);

for n = 2:numBases-1

newAcceleration(n) = kappa * (x(n+1, i) - 2 * x(n, i) + x(n-1, i)) ...

- delta * initialVelocities(n) - omegaD^2 * (x(n, i) - beta * x(n, i)^3);

end

initialVelocities(2:numBases-1) = initialVelocities(2:numBases-1) + 0.5 * dt * (acceleration(2:numBases-1) + newAcceleration(2:numBases-1));

end

% Visualization of displacement over time for each base pair

figure;

hold on;

for n = 2:numBases-1

plot(tspan, x(n, :));

end

xlabel('Time');

ylabel('Displacement');

legend(arrayfun(@(n) ['Base ' num2str(n)], 2:numBases-1, 'UniformOutput', false));

title('Displacement of DNA Bases Over Time');

hold off;

The results are visualized using a plot that shows the displacements of each base over time . Key observations from the simulation include :

- Wave Propagation: The initial perturbations lead to wave-like dynamics along the segment, with visible propagation and reflection at the boundaries.
- Damping Effects: The inclusion of damping leads to a gradual reduction in the amplitude of the oscillations, indicating energy dissipation over time.
- Nonlinear Behavior: The nonlinear term influences the response, potentially stabilizing the system against large displacements or leading to complex dynamic patterns.

% 3D plot for displacement

figure;

[X, T] = meshgrid(1:numBases, tspan);

surf(X', T', x);

xlabel('Base Pair');

ylabel('Time');

zlabel('Displacement');

title('3D View of DNA Base Displacements');

colormap('jet');

shading interp;

colorbar; % Adds a color bar to indicate displacement magnitude

% Snapshot visualization at a specific time

snapshotTime = 40; % Desired time for the snapshot

[~, snapshotIndex] = min(abs(tspan - snapshotTime)); % Find closest index

snapshotSolution = x(:, snapshotIndex); % Extract displacement at the snapshot time

% Plotting the snapshot

figure;

stem(1:numBases, snapshotSolution, 'filled'); % Discrete plot using stem

title(sprintf('DNA Model Displacement at t = %d seconds', snapshotTime));

xlabel('Base Pair Index');

ylabel('Displacement');

% Time vector for detailed sampling

tDetailed = 0:0.5:50; % Detailed time steps

% Initialize an empty array to hold the data

data = [];

% Generate the data for 3D plotting

for i = 1:numBases

% Interpolate to get detailed solution data for each base pair

detailedSolution = interp1(tspan, x(i, :), tDetailed);

% Concatenate the current base pair's data to the main data array

data = [data; repmat(i, length(tDetailed), 1), tDetailed', detailedSolution'];

end

% 3D Plot

figure;

scatter3(data(:,1), data(:,2), data(:,3), 10, data(:,3), 'filled');

xlabel('Base Pair');

ylabel('Time');

zlabel('Displacement');

title('3D Plot of DNA Base Pair Displacements Over Time');

colorbar; % Adds a color bar to indicate displacement magnitude

As far as I know, the MATLAB Community (including Matlab Central and Mathworks' official GitHub repository) has always been a vibrant and diverse professional and amateur community of MATLAB users from various fields globally. Being a part of it myself, especially in recent years, I have not only benefited continuously from the community but also tried to give back by helping other users in need.

I am a senior MATLAB user from Shenzhen, China, and I have a deep passion for MATLAB, applying it in various scenarios. Due to the less than ideal job market in my current social environment, I am hoping to find a position for remote support work within the Matlab Community. I wonder if this is realistic. For instance, Mathworks has been open-sourcing many repositories in recent years, especially in the field of deep learning with typical applications across industries. I am eager to use the latest MATLAB features to implement state-of-the-art algorithms. Additionally, I occasionally contribute through GitHub issues and pull requests.

In conclusion, I am looking forward to the opportunity to formally join the Matlab Community in a remote support role, dedicating more energy to giving back to the community and making the world a better place! (If a Mathworks employer can contact me, all the better~)

I created an ellipse visualizer in #MATLAB using App Designer! To read more about it, and how it ties to the recent total solar eclipse, check out my latest blog post:

Github Repo of the app (you can open it on MATLAB Online!):

The latest release is pretty much upon us. Official annoucements will be coming soon and the eagle-eyed among you will have started to notice some things shifting around on the MathWorks website as we ready for this.

The pre-release has been available for a while. Maybe you've played with it? I have...I've even been quietly using it to write some of my latest blog posts...and I have several queued up for publication after MathWorks officially drops the release.

At the time of writing, this page points to the pre-release highlights. Prerelease Release Highlights - MATLAB & Simulink (mathworks.com)

What excites you about this release? why?

I found this link posted on Reddit.

https://workhunty.com/job-blog/where-is-the-best-place-to-be-a-programmer/Matlab/

I'm excited to share some valuable resources that I've found to be incredibly helpful for anyone looking to enhance their MATLAB skills. Whether you're just starting out, studying as a student, or are a seasoned professional, these guides and books offer a wealth of information to aid in your learning journey.

These materials are freely available and can be a great addition to your learning resources. They cover a wide range of topics and are designed to help users at all levels to improve their proficiency in MATLAB.

Happy learning and I hope you find these resources as useful as I have!

Let S be the closed surface composed of the hemisphere and the base Let be the electric field defined by . Find the electric flux through S. (Hint: Divide S into two parts and calculate ).

% Define the limits of integration for the hemisphere S1

theta_lim = [-pi/2, pi/2];

phi_lim = [0, pi/2];

% Perform the double integration over the spherical surface of the hemisphere S1

% Define the electric flux function for the hemisphere S1

flux_function_S1 = @(theta, phi) 2 * sin(phi);

electric_flux_S1 = integral2(flux_function_S1, theta_lim(1), theta_lim(2), phi_lim(1), phi_lim(2));

% For the base of the hemisphere S2, the electric flux is 0 since the electric

% field has no z-component at the base

electric_flux_S2 = 0;

% Calculate the total electric flux through the closed surface S

total_electric_flux = electric_flux_S1 + electric_flux_S2;

% Display the flux calculations

disp(['Electric flux through the hemisphere S1: ', num2str(electric_flux_S1)]);

disp(['Electric flux through the base of the hemisphere S2: ', num2str(electric_flux_S2)]);

disp(['Total electric flux through the closed surface S: ', num2str(total_electric_flux)]);

% Parameters for the plot

radius = 1; % Radius of the hemisphere

% Create a meshgrid for theta and phi for the plot

[theta, phi] = meshgrid(linspace(theta_lim(1), theta_lim(2), 20), linspace(phi_lim(1), phi_lim(2), 20));

% Calculate Cartesian coordinates for the points on the hemisphere

x = radius * sin(phi) .* cos(theta);

y = radius * sin(phi) .* sin(theta);

z = radius * cos(phi);

% Define the electric field components

Ex = 2 * x;

Ey = 2 * y;

Ez = 2 * z;

% Plot the hemisphere

figure;

surf(x, y, z, 'FaceAlpha', 0.5, 'EdgeColor', 'none');

hold on;

% Plot the electric field vectors

quiver3(x, y, z, Ex, Ey, Ez, 'r');

% Plot the base of the hemisphere

[x_base, y_base] = meshgrid(linspace(-radius, radius, 20), linspace(-radius, radius, 20));

z_base = zeros(size(x_base));

surf(x_base, y_base, z_base, 'FaceColor', 'cyan', 'FaceAlpha', 0.3);

% Additional plot settings

colormap('cool');

axis equal;

grid on;

xlabel('X');

ylabel('Y');

zlabel('Z');

title('Hemisphere and Electric Field');

Although, I think I will only get to see a partial eclipse (April 8th!) from where I am at in the U.S. I will always have MATLAB to make my own solar eclipse. Just as good as the real thing.

Code (found on the @MATLAB instagram)

a=716;

v=255;

X=linspace(-10,10,a);

[~,r]=cart2pol(X,X');

colormap(gray.*[1 .78 .3]);

[t,g]=cart2pol(X+2.6,X'+1.4);

image(rescale(-1*(2*sin(t*10)+60*g.^.2),0,v))

hold on

h=exp(-(r-3)).*abs(ifft2(r.^-1.8.*cos(7*rand(a))));

h(r<3)=0;

image(v*ones(a),'AlphaData',rescale(h,0,1))

camva(3.8)

Lots of students like me have a break from school this week or next! If y'all are looking for something interesting to do learn a bit about using hgtransform by making the transforming snake animation in MATLAB!

Code below!

⬇️⬇️⬇️

numblock=24;

v = [ -1 -1 -1 ; 1 -1 -1 ; -1 1 -1 ; -1 1 1 ; -1 -1 1 ; 1 -1 1 ];

f = [ 1 2 3 nan; 5 6 4 nan; 1 2 6 5; 1 5 4 3; 3 4 6 2 ];

clr = hsv(numblock);

shapes = [ 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 % box

0 0 .5 -.5 .5 0 1 0 -.5 .5 -.5 0 1 0 .5 -.5 .5 0 1 0 -.5 .5 -.5 0 % fluer

0 0 1 1 0 .5 -.5 1 .5 .5 -.5 -.5 1 .5 .5 -.5 -.5 1 .5 .5 -.5 -.5 1 .5 % bowl

0 .5 -.5 -.5 .5 -.5 .5 .5 -.5 .5 -.5 -.5 .5 -.5 .5 .5 -.5 .5 -.5 -.5 .5 -.5 .5 .5]; % ball

% Build the assembly

set(gcf,'color','black');

daspect(newplot,[1 1 1]);

xform=@(R)makehgtform('axisrotate',[0 1 0],R,'zrotate',pi/2,'yrotate',pi,'translate',[2 0 0]);

P=hgtransform('Parent',gca,'Matrix',makehgtform('xrotate',pi*.5,'zrotate',pi*-.8));

for i = 1:numblock

P = hgtransform('Parent',P,'Matrix',xform(shapes(end,i)*pi));

patch('Parent',P, 'Vertices', v, 'Faces', f, 'FaceColor',clr(i,:),'EdgeColor','none');

patch('Parent',P, 'Vertices', v*.75, 'Faces', f(end,:), 'FaceColor','none',...

'EdgeColor','w','LineWidth',2);

end

view([10 60]);

axis tight vis3d off

camlight

% Setup vectors for animation

h=findobj(gca,'type','hgtransform')'; h=h(2:end);

r=shapes(end,:)*pi;

steps=100;

% Animate between different shapes

for si = 1:size(shapes,1)

sh = shapes(si,:)*pi;

diff = (sh-r)/steps;

% Animate to a new shape

for s=1:steps

arrayfun(@(tx)set(h(tx),'Matrix',xform(r(tx)+diff(tx)*s)),1:numblock);

view([s*360/steps 20]); drawnow();

end

r=sh;

for s=1:steps; view([s*360/steps 20]); drawnow(); end % finish rotate

end

Before we begin, you will need to make sure you have 'sir_age_model.m' installed. Once you've downloaded this folder into your working directory, which can be located at your current folder. If you can see this file in your current folder, then it's safe to use it. If you choose to use MATLAB online or MATLAB Mobile, you may upload this to your MATLAB Drive.

This is the code for the SIR model stratified into 2 age groups (children and adults). For a detailed explanation of how to derive the force of infection by age group.

% Main script to run the SIR model simulation

% Initial state values

initial_state_values = [200000; 1; 0; 800000; 0; 0]; % [S1; I1; R1; S2; I2; R2]

% Parameters

parameters = [0.05; 7; 6; 1; 10; 1/5]; % [b; c_11; c_12; c_21; c_22; gamma]

% Time span for the simulation (3 months, with daily steps)

tspan = [0 90];

% Solve the ODE

[t, y] = ode45(@(t, y) sir_age_model(t, y, parameters), tspan, initial_state_values);

% Plotting the results

plot(t, y);

xlabel('Time (days)');

ylabel('Number of people');

legend('S1', 'I1', 'R1', 'S2', 'I2', 'R2');

title('SIR Model with Age Structure');

What was the cumulative incidence of infection during this epidemic? What proportion of those infections occurred in children?

In the SIR model, the cumulative incidence of infection is simply the decline in susceptibility.

% Assuming 'y' contains the simulation results from the ode45 function

% and 't' contains the time points

% Total cumulative incidence

total_cumulative_incidence = (y(1,1) - y(end,1)) + (y(1,4) - y(end,4));

fprintf('Total cumulative incidence: %f\n', total_cumulative_incidence);

% Cumulative incidence in children

cumulative_incidence_children = (y(1,1) - y(end,1));

% Proportion of infections in children

proportion_infections_children = cumulative_incidence_children / total_cumulative_incidence;

fprintf('Proportion of infections in children: %f\n', proportion_infections_children);

927,447 people became infected during this epidemic, 20.5% of which were children.

Which age group was most affected by the epidemic?

To answer this, we can calculate the proportion of children and adults that became infected.

% Assuming 'y' contains the simulation results from the ode45 function

% and 't' contains the time points

% Proportion of children that became infected

initial_children = 200000; % initial number of susceptible children

final_susceptible_children = y(end,1); % final number of susceptible children

proportion_infected_children = (initial_children - final_susceptible_children) / initial_children;

fprintf('Proportion of children that became infected: %f\n', proportion_infected_children);

% Proportion of adults that became infected

initial_adults = 800000; % initial number of susceptible adults

final_susceptible_adults = y(end,4); % final number of susceptible adults

proportion_infected_adults = (initial_adults - final_susceptible_adults) / initial_adults;

fprintf('Proportion of adults that became infected: %f\n', proportion_infected_adults);

Throughout this epidemic, 95% of all children and 92% of all adults were infected. Children were therefore slightly more affected in proportion to their population size, even though the majority of infections occurred in adults.

The stationary solutions of the Klein-Gordon equation refer to solutions that are time-independent, meaning they remain constant over time. For the non-linear Klein-Gordon equation you are discussing:

Stationary solutions arise when the time derivative term, , is zero, meaning the motion of the system does not change over time. This leads to a static differential equation:

This equation describes how particles in the lattice interact with each other and how non-linearity affects the steady state of the system.

The solutions to this equation correspond to the various possible stable equilibrium states of the system, where each represents different static distribution patterns of displacements . The specific form of these stationary solutions depends on the system parameters, such as κ , ω, and β , as well as the initial and boundary conditions of the problem.

To find these solutions in a more specific form, one might need to solve the equation using analytical or numerical methods, considering the different cases that could arise in such a non-linear system.

By interpreting the equation in this way, we can relate the dynamics described by the discrete Klein - Gordon equation to the behavior of DNA molecules within a biological system . This analogy allows us to understand the behavior of DNA in terms of concepts from physics and mathematical modeling .

% Parameters

numBases = 100; % Number of spatial points

omegaD = 0.2; % Common parameter for the equation

% Preallocate the array for the function handles

equations = cell(numBases, 1);

% Initial guess for the solution

initialGuess = 0.01 * ones(numBases, 1);

% Parameter sets for kappa and beta

paramSets = [0.1, 0.05; 0.5, 0.05; 0.1, 0.2];

% Prepare figure for subplot

figure;

set(gcf, 'Position', [100, 100, 1200, 400]); % Set figure size

% Newton-Raphson method parameters

maxIterations = 1000;

tolerance = 1e-10;

% Set options for fsolve to use the 'levenberg-marquardt' algorithm

options = optimoptions('fsolve', 'Algorithm', 'levenberg-marquardt', 'MaxIterations', maxIterations, 'FunctionTolerance', tolerance);

for i = 1:size(paramSets, 1)

kappa = paramSets(i, 1);

beta = paramSets(i, 2);

% Define the equations using a function

for n = 2:numBases-1

equations{n} = @(x) -kappa * (x(n+1) - 2 * x(n) + x(n-1)) - omegaD^2 * (x(n) - beta * x(n)^3);

end

% Boundary conditions with specified fixed values

someFixedValue1 = 10; % Replace with actual value if needed

someFixedValue2 = 10; % Replace with actual value if needed

equations{1} = @(x) x(1) - someFixedValue1;

equations{numBases} = @(x) x(numBases) - someFixedValue2;

% Combine all equations into a single function

F = @(x) cell2mat(cellfun(@(f) f(x), equations, 'UniformOutput', false));

% Solve the system of equations using fsolve with the specified options

x_solution = fsolve(F, initialGuess, options);

norm(F(x_solution))

% Plot the solution in a subplot

subplot(1, 3, i);

plot(x_solution, 'o-', 'LineWidth', 2);

grid on;

xlabel('n', 'FontSize', 12);

ylabel('x[n]', 'FontSize', 12);

title(sprintf('\\kappa = %.2f, \\beta = %.2f', kappa, beta), 'FontSize', 14);

end

% Improve overall aesthetics

sgtitle('Stationary States for Different \kappa and \beta Values', 'FontSize', 16); % Super title for the figure

In the second plot, the elasticity constant κis increased to 0.5, representing a system with greater stiffness . This parameter influences how resistant the system is to deformation, implying that a higher κ makes the system more resilient to changes . By increasing κ, we are essentially tightening the interactions between adjacent units in the model, which could represent, for instance, stronger bonding forces in a physical or biological system .

In the third plot the nonlinearity coefficient β is increased to 0.2 . This adjustment enhances the nonlinear interactions within the system, which can lead to more complex dynamic behaviors, especially in systems exhibiting bifurcations or chaos under certain conditions .

First, I felt that the three answers provided by a user in this thread might have been generated by AI. How do you think?

Second, I found that "Responsible usage of generative AI tools, such as ChatGPT, is allowed in MATLAB Answers."

If the answers are indeed AI generated, then the user didn't do "clearly indicating when AI generated content is incorporated".

That leads to my question that how do we enforce the guideline.

I am not against using AI for answers but in this case, I felt the answering text is mentioning all the relevant words but missing the point. For novice users who are seeking answers, this would be misleading and waste of time.

The following expression

gives the solution for the Helmholtz problem. On the circular disc with center 0 and radius a. For the plot in 3-dimensional graphics of the solutions on Matlab for and then calculate some eigenfunctions with the following expression.

It could be better to separate functions with and as follows

diska = 1; % Radius of the disk

mmax = 2; % Maximum value of m

nmax = 2; % Maximum value of n

% Function to find the k-th zero of the n-th Bessel function

% This function uses a more accurate method for initial guess

besselzero = @(n, k) fzero(@(x) besselj(n, x), [(k-(n==0))*pi, (k+1-(n==0))*pi]);

% Define the eigenvalue k[m, n] based on the zeros of the Bessel function

k = @(m, n) besselzero(n, m);

% Define the functions uc and us using Bessel functions

% These functions represent the radial part of the solution

uc = @(r, t, m, n) cos(n * t) .* besselj(n, k(m, n) * r);

us = @(r, t, m, n) sin(n * t) .* besselj(n, k(m, n) * r);

% Generate data for demonstration

data = zeros(5, 3);

for m = 1:5

for n = 0:2

data(m, n+1) = k(m, n); % Storing the eigenvalues

end

end

% Display the data

disp(data);

% Plotting all in one figure

figure;

plotIndex = 1;

for n = 0:nmax

for m = 1:mmax

subplot(nmax + 1, mmax, plotIndex);

[X, Y] = meshgrid(linspace(-diska, diska, 100), linspace(-diska, diska, 100));

R = sqrt(X.^2 + Y.^2);

T = atan2(Y, X);

Z = uc(R, T, m, n); % Using uc for plotting

% Ensure the plot is only within the disk

Z(R > diska) = NaN;

mesh(X, Y, Z);

title(sprintf('uc: n=%d, m=%d', n, m));

colormap('jet');

plotIndex = plotIndex + 1;

end

end