Visualization of Complex Function Mapping Homotopy

A simple function artistically visualizes the complex function transformation with homotopy.

function complex_viz_combined()

% --- Configuration ---

config.density_2d = 100; % Grid density for 2D

config.density_3d = 80; % Grid density for 3D

config.anim_steps = 150; % Frames per animation

config.bg_color = [0.02 0.02 0.05]; % Dark background

config.clamp_limit = 12; % Visual extent limit

config.z_limit = 8; % Max height for 3D plots

config.line_width = 1.0;

% --- Setup Canvas ---

f = figure('Name', 'The Ultimate Math Visualization', ...

'NumberTitle', 'off', ...

'Color', config.bg_color, ...

'Position', [100, 100, 1280, 720], ...

'MenuBar', 'none', 'ToolBar', 'none');

ax = axes('Parent', f, 'Color', config.bg_color, ...

'XColor', [0.4 0.4 0.5], 'YColor', [0.4 0.4 0.5], 'ZColor', [0.4 0.4 0.5], ...

'LineWidth', 1, 'NextPlot', 'replacechildren');

% --- Scene Definitions ---

scenes = struct();

idx = 1;

% 1. Squaring (z^2)

scenes(idx).mode = '2D'; scenes(idx).name = 'Squaring (2D): z^2';

scenes(idx).func = @(z) z.^2;

scenes(idx).xlim = [-3, 3]; scenes(idx).ylim = [-3, 3];

scenes(idx).view = [-9, 9];

idx = idx + 1;

scenes(idx).mode = '3D'; scenes(idx).name = 'The Bowl (3D): z^2';

scenes(idx).func = @(z) z.^2;

scenes(idx).xlim = [-2, 2]; scenes(idx).ylim = [-2, 2];

scenes(idx).view = [-4, 4];

idx = idx + 1;

% 2. Exponential (e^z)

scenes(idx).mode = '2D'; scenes(idx).name = 'Exponential (2D): e^z';

scenes(idx).func = @(z) exp(z);

scenes(idx).xlim = [-2.5, 2.5]; scenes(idx).ylim = [-2*pi, 2*pi];

scenes(idx).view = [-10, 10];

idx = idx + 1;

scenes(idx).mode = '3D'; scenes(idx).name = 'The Spiral Slope (3D): e^z';

scenes(idx).func = @(z) exp(z);

scenes(idx).xlim = [-2, 2]; scenes(idx).ylim = [-3*pi, 3*pi];

scenes(idx).view = [-8, 8];

idx = idx + 1;

% 3. Sine (sin(z))

scenes(idx).mode = '2D'; scenes(idx).name = 'Sine Wave (2D): sin(z)';

scenes(idx).func = @(z) sin(z);

scenes(idx).xlim = [-2*pi, 2*pi]; scenes(idx).ylim = [-2.5, 2.5];

scenes(idx).view = [-6, 6];

idx = idx + 1;

scenes(idx).mode = '3D'; scenes(idx).name = 'The Modular Wave (3D): sin(z)';

scenes(idx).func = @(z) sin(z);

scenes(idx).xlim = [-2*pi, 2*pi]; scenes(idx).ylim = [-2, 2];

scenes(idx).view = [-4, 4];

idx = idx + 1;

% 4. Inversion (1/z)

scenes(idx).mode = '2D'; scenes(idx).name = 'Inversion (2D): 1/z';

scenes(idx).func = @(z) 1./z;

scenes(idx).xlim = [-3, 3]; scenes(idx).ylim = [-3, 3];

scenes(idx).view = [-6, 6];

idx = idx + 1;

scenes(idx).mode = '3D'; scenes(idx).name = 'Gravity Well (3D): 1/z';

scenes(idx).func = @(z) 1./z;

scenes(idx).xlim = [-2.5, 2.5]; scenes(idx).ylim = [-2.5, 2.5];

scenes(idx).view = [-4, 4];

idx = idx + 1;

% 5. Riemann Zeta

scenes(idx).mode = '2D'; scenes(idx).name = 'Riemann Zeta (2D): Chaos';

scenes(idx).func = @safe_zeta;

scenes(idx).xlim = [-12, 12]; scenes(idx).ylim = [-12, 12];

scenes(idx).view = [-10, 10];

idx = idx + 1;

scenes(idx).mode = '3D'; scenes(idx).name = 'Riemann Landscape (3D)';

scenes(idx).func = @safe_zeta;

scenes(idx).xlim = [-12, 12]; scenes(idx).ylim = [-12, 12];

scenes(idx).view = [-10, 10];

idx = idx + 1;

% --- Main Loop ---

for s = 1:length(scenes)

fprintf('Rendering %d/%d: %s...\n', s, length(scenes), scenes(s).name);

try

if strcmp(scenes(s).mode, '2D')

render_2d(f, ax, scenes(s), config);

else

render_3d(f, ax, scenes(s), config);

end

catch ME

fprintf('Error: %s\n', ME.message);

end

pause(1); % Pause between scenes

end

disp('Visualization Complete.');

end

% ==============================================================================

% 2D RENDER ENGINE

% ==============================================================================

function render_2d(f, ax, scene, config)

cla(ax); view(ax, 2); axis(ax, 'equal'); grid(ax, 'on'); hold(ax, 'on');

ax.GridAlpha = 0.15; ax.GridColor = 'w';

title(ax, scene.name, 'Color', [0.8 0.9 1], 'FontSize', 16, 'FontName', 'FixedWidth');

% Generate Grid

nx = config.density_2d; ny = config.density_2d;

x = linspace(scene.xlim(1), scene.xlim(2), nx);

y = linspace(scene.ylim(1), scene.ylim(2), ny);

[X, Y] = meshgrid(x, y);

Z_orig = X + 1i*Y;

try Z_target = scene.func(Z_orig); catch, return; end

% Apply NaN Clamping for clean cutouts

mask = abs(Z_target) > config.clamp_limit;

Z_target(mask) = NaN;

% Initialize Lines

h_lines = gobjects(1, ny);

v_lines = gobjects(1, nx);

cmap_h = [linspace(0,0,ny)', linspace(1,0.4,ny)', linspace(1,1,ny)'];

cmap_v = [linspace(1,1,nx)', linspace(0,0.5,nx)', linspace(1,0,nx)'];

for k = 1:ny

h_lines(k) = plot(ax, real(Z_orig(k,:)), imag(Z_orig(k,:)), ...

'Color', [cmap_h(k,:) 0.6], 'LineWidth', config.line_width);

end

for k = 1:nx

v_lines(k) = plot(ax, real(Z_orig(:,k)), imag(Z_orig(:,k)), ...

'Color', [cmap_v(k,:) 0.6], 'LineWidth', config.line_width);

end

% Set View

xlim(ax, scene.xlim*1.2); ylim(ax, scene.ylim*1.2);

% Animation Loop

t_vals = linspace(0, 1, config.anim_steps);

t_smooth = 1 ./ (1 + exp(-10 * (t_vals - 0.5)));

t_smooth = (t_smooth - min(t_smooth)) / (max(t_smooth) - min(t_smooth));

for t = t_smooth

Z_curr = (1-t)*Z_orig + t*Z_target;

for k = 1:ny, set(h_lines(k), 'XData', real(Z_curr(k,:)), 'YData', imag(Z_curr(k,:))); end

for k = 1:nx, set(v_lines(k), 'XData', real(Z_curr(:,k)), 'YData', imag(Z_curr(:,k))); end

% Dynamic Camera Zoom

curr_view = (1-t)*(scene.xlim*1.2) + t*[scene.view(1) scene.view(2)];

xlim(ax, curr_view); ylim(ax, curr_view);

drawnow;

end

end

% ==============================================================================

% 3D RENDER ENGINE

% ==============================================================================

function render_3d(f, ax, scene, config)

cla(ax); grid(ax, 'on'); hold(ax, 'on');

ax.GridAlpha = 0.15; ax.GridColor = 'w';

xlabel(ax,'Re'); ylabel(ax,'Im'); zlabel(ax,'Magnitude');

title(ax, scene.name, 'Color', [1 0.8 0.5], 'FontSize', 16, 'FontName', 'FixedWidth');

nx = config.density_3d; ny = config.density_3d;

x = linspace(scene.xlim(1), scene.xlim(2), nx);

y = linspace(scene.ylim(1), scene.ylim(2), ny);

[X, Y] = meshgrid(x, y);

Z_orig = X + 1i*Y;

try Z_target = scene.func(Z_orig); catch, return; end

% 3D Coordinates

X_t = real(Z_target);

Y_t = imag(Z_target);

H_t = abs(Z_target);

% Clamping: NaN for horizontal overflow, Cap for vertical height

radii = abs(Z_target);

mask_xy = radii > config.clamp_limit;

X_t(mask_xy) = NaN;

Y_t(mask_xy) = NaN;

H_t(mask_xy) = NaN;

H_t(H_t > config.z_limit) = config.z_limit;

X_0 = real(Z_orig); Y_0 = imag(Z_orig); H_0 = zeros(size(Z_orig));

% Initialize Lines

h_lines = gobjects(1, ny);

v_lines = gobjects(1, nx);

cmap = spring(ny + nx);

for k = 1:ny

h_lines(k) = plot3(ax, X_0(k,:), Y_0(k,:), H_0(k,:), ...

'Color', [cmap(k,:) 0.7], 'LineWidth', config.line_width);

end

for k = 1:nx

v_lines(k) = plot3(ax, X_0(:,k), Y_0(:,k), H_0(:,k), ...

'Color', [cmap(k+ny,:) 0.7], 'LineWidth', config.line_width);

end

% Fixed View

axis(ax, 'equal');

xlim(ax, scene.view); ylim(ax, scene.view); zlim(ax, [0, config.z_limit]);

view(ax, 45, 35);

% Animation Loop

t_vals = linspace(0, 1, config.anim_steps);

t_smooth = 1 ./ (1 + exp(-10 * (t_vals - 0.5)));

t_smooth = (t_smooth - min(t_smooth)) / (max(t_smooth) - min(t_smooth));

for t = t_smooth

X_curr = (1-t)*X_0 + t*X_t;

Y_curr = (1-t)*Y_0 + t*Y_t;

H_curr = (1-t)*H_0 + t*H_t;

for k = 1:ny, set(h_lines(k), 'XData', X_curr(k,:), 'YData', Y_curr(k,:), 'ZData', H_curr(k,:)); end

for k = 1:nx, set(v_lines(k), 'XData', X_curr(:,k), 'YData', Y_curr(:,k), 'ZData', H_curr(:,k)); end

drawnow;

end

end

% --- Helper Functions ---

function z_out = safe_zeta(z_in)

try

z_out = zeta(z_in);

catch

% Fallback approximation if Symbolic Toolbox is missing

z_out = 0.5 ./ (z_in.^0.5) + sin(z_in*5)*0.1;

end

% Hard clamp for pole at s=1

z_out(abs(z_in - 1) < 0.15) = NaN;

end