MATLAB Matlab source

AI-powered detection and analysis of Matlab source files.

📂 Code

🏷️ .m

🎯 text/x-matlab

🔍

Instant MATLAB File Detection

Use our advanced AI-powered tool to instantly detect and analyze Matlab source files with precision and speed.

File Information

File Description

Matlab source

MATLAB Programming Language

What is a MATLAB file?

A MATLAB (.m) file is a script or function file written in MATLAB (Matrix Laboratory), a high-level programming language and interactive environment designed for numerical computing, data analysis, and algorithm development. MATLAB files contain mathematical computations, data visualization commands, and engineering algorithms that leverage MATLAB's powerful matrix operations and extensive toolbox ecosystem for scientific and engineering applications.

More Information

MATLAB was developed by Cleve Moler in the late 1970s while he was a professor at the University of New Mexico. Originally created as a simple interface to LINPACK and EISPACK Fortran libraries, MATLAB evolved into a comprehensive technical computing platform. MathWorks was founded in 1984 to develop and commercialize MATLAB, which has since become an industry standard in engineering, scientific research, and academic institutions worldwide.

MATLAB's design philosophy centers around matrix operations and vectorized computing, making it exceptionally powerful for numerical analysis, linear algebra, and mathematical modeling. The platform combines a programming language with a desktop environment tuned for iterative analysis and design processes. MATLAB's extensive collection of specialized toolboxes covers virtually every engineering and scientific discipline, from signal processing and control systems to machine learning and financial modeling.

MATLAB Format

MATLAB uses a syntax optimized for mathematical operations and matrix manipulation:

Basic Syntax

Matrix-centric - Everything is treated as a matrix
Vectorized operations - Operations work on entire arrays
Functions and scripts - .m files can be scripts or functions
Comments - Lines starting with % symbol
Semicolon suppression - Semicolon suppresses output display
Case sensitivity - Variable and function names are case-sensitive

Key Features

Matrix operations - Built-in support for linear algebra
Vectorization - Efficient operations on arrays
Built-in functions - Comprehensive mathematical function library
Toolboxes - Specialized function collections
Graphics and visualization - Powerful plotting capabilities
Interactive environment - Command window for exploration

Data Types and Structures

Numeric arrays - double (default), single, integer types
Logical arrays - Boolean data
Character arrays - Text and string data
Cell arrays - Heterogeneous data containers
Structures - Named field containers
Tables - Structured data with named variables
Categorical arrays - Discrete categories

Example MATLAB Script

%% =====================================================
%% Signal Processing and Analysis Toolbox
%% Purpose: Comprehensive signal analysis and filtering
%% Author: Signal Processing Engineer
%% Date: Created on [date()]
%% =====================================================

%% Clear workspace and set up environment
clear all; close all; clc;

% Set random seed for reproducibility
rng(42);

% Configuration parameters
fs = 1000;              % Sampling frequency (Hz)
T = 2;                  % Duration (seconds)
t = 0:1/fs:T-1/fs;      % Time vector
N = length(t);          % Number of samples

%% Generate test signals
fprintf('Generating test signals...\n');

% Clean sinusoidal signals
f1 = 50;    % Frequency of first component (Hz)
f2 = 120;   % Frequency of second component (Hz)
f3 = 200;   % Frequency of third component (Hz)

% Create composite signal
signal_clean = 2*sin(2*pi*f1*t) + 1.5*sin(2*pi*f2*t) + 0.8*sin(2*pi*f3*t);

% Add noise
noise_level = 0.5;
noise = noise_level * randn(size(t));
signal_noisy = signal_clean + noise;

% Add some non-stationary components
chirp_component = 0.5 * sin(2*pi*(10 + 30*t).*t);  % Frequency sweep
signal_complex = signal_noisy + chirp_component;

%% Signal Analysis Function
function [freq, magnitude, phase] = analyze_spectrum(signal, fs)
    % Compute FFT and frequency domain analysis
    N = length(signal);
    Y = fft(signal);
    P2 = abs(Y/N);
    P1 = P2(1:N/2+1);
    P1(2:end-1) = 2*P1(2:end-1);
    
    freq = fs*(0:(N/2))/N;
    magnitude = P1;
    phase = angle(Y(1:N/2+1));
end

%% Frequency domain analysis
fprintf('Performing frequency domain analysis...\n');

[freq, mag_clean, phase_clean] = analyze_spectrum(signal_clean, fs);
[~, mag_noisy, phase_noisy] = analyze_spectrum(signal_noisy, fs);
[~, mag_complex, phase_complex] = analyze_spectrum(signal_complex, fs);

%% Design and apply filters
fprintf('Designing and applying filters...\n');

% Low-pass filter design (Butterworth)
fc_low = 150;                           % Cutoff frequency
[b_low, a_low] = butter(6, fc_low/(fs/2), 'low');

% Band-pass filter design
fc_band = [40 130];                     % Passband frequencies
[b_band, a_band] = butter(4, fc_band/(fs/2), 'bandpass');

% High-pass filter design
fc_high = 80;                           % Cutoff frequency
[b_high, a_high] = butter(4, fc_high/(fs/2), 'high');

% Apply filters
signal_lowpass = filtfilt(b_low, a_low, signal_complex);
signal_bandpass = filtfilt(b_band, a_band, signal_complex);
signal_highpass = filtfilt(b_high, a_high, signal_complex);

%% Advanced signal processing
fprintf('Applying advanced signal processing techniques...\n');

% Spectrogram analysis
window_size = 128;
overlap = 64;
nfft = 256;

[S, F, T_spec] = spectrogram(signal_complex, window_size, overlap, nfft, fs);
S_magnitude = abs(S);

% Wavelet analysis
wavelet_name = 'db4';
[coeffs, freqs_wav] = cwt(signal_complex, 1:100, wavelet_name, 1/fs);

% Statistical analysis
function stats = compute_signal_stats(signal)
    stats.mean = mean(signal);
    stats.std = std(signal);
    stats.rms = rms(signal);
    stats.peak = max(abs(signal));
    stats.crest_factor = stats.peak / stats.rms;
    stats.skewness = skewness(signal);
    stats.kurtosis = kurtosis(signal);
end

stats_original = compute_signal_stats(signal_complex);
stats_filtered = compute_signal_stats(signal_lowpass);

%% Visualization
fprintf('Creating visualizations...\n');

% Create comprehensive figure
figure('Position', [100, 100, 1400, 900]);

% Time domain plots
subplot(3, 4, 1);
plot(t, signal_clean, 'b-', 'LineWidth', 1.5);
title('Clean Signal');
xlabel('Time (s)'); ylabel('Amplitude');
grid on;

subplot(3, 4, 2);
plot(t, signal_noisy, 'r-', 'LineWidth', 1);
title('Noisy Signal');
xlabel('Time (s)'); ylabel('Amplitude');
grid on;

subplot(3, 4, 3);
plot(t, signal_complex, 'k-', 'LineWidth', 1);
title('Complex Signal');
xlabel('Time (s)'); ylabel('Amplitude');
grid on;

subplot(3, 4, 4);
plot(t, signal_lowpass, 'g-', 'LineWidth', 1.5);
title('Low-pass Filtered');
xlabel('Time (s)'); ylabel('Amplitude');
grid on;

% Frequency domain plots
subplot(3, 4, 5);
semilogx(freq, 20*log10(mag_clean), 'b-', 'LineWidth', 1.5);
title('Clean Signal Spectrum');
xlabel('Frequency (Hz)'); ylabel('Magnitude (dB)');
grid on;

subplot(3, 4, 6);
semilogx(freq, 20*log10(mag_complex), 'k-', 'LineWidth', 1);
title('Complex Signal Spectrum');
xlabel('Frequency (Hz)'); ylabel('Magnitude (dB)');
grid on;

% Filter responses
subplot(3, 4, 7);
[h_low, w_low] = freqz(b_low, a_low, 1024, fs);
plot(w_low, 20*log10(abs(h_low)), 'g-', 'LineWidth', 2);
title('Low-pass Filter Response');
xlabel('Frequency (Hz)'); ylabel('Magnitude (dB)');
grid on;

subplot(3, 4, 8);
[h_band, w_band] = freqz(b_band, a_band, 1024, fs);
plot(w_band, 20*log10(abs(h_band)), 'm-', 'LineWidth', 2);
title('Band-pass Filter Response');
xlabel('Frequency (Hz)'); ylabel('Magnitude (dB)');
grid on;

% Spectrogram
subplot(3, 4, 9:10);
imagesc(T_spec, F, 20*log10(S_magnitude));
axis xy;
colorbar;
title('Spectrogram');
xlabel('Time (s)'); ylabel('Frequency (Hz)');

% Wavelet scalogram
subplot(3, 4, 11:12);
imagesc(t, freqs_wav, abs(coeffs));
axis xy;
colorbar;
title('Continuous Wavelet Transform');
xlabel('Time (s)'); ylabel('Frequency (Hz)');

%% Statistical analysis and reporting
fprintf('\n=== SIGNAL ANALYSIS REPORT ===\n');
fprintf('Original Signal Statistics:\n');
fprintf('  Mean: %.4f\n', stats_original.mean);
fprintf('  Standard Deviation: %.4f\n', stats_original.std);
fprintf('  RMS: %.4f\n', stats_original.rms);
fprintf('  Peak: %.4f\n', stats_original.peak);
fprintf('  Crest Factor: %.4f\n', stats_original.crest_factor);
fprintf('  Skewness: %.4f\n', stats_original.skewness);
fprintf('  Kurtosis: %.4f\n', stats_original.kurtosis);

fprintf('\nFiltered Signal Statistics:\n');
fprintf('  Mean: %.4f\n', stats_filtered.mean);
fprintf('  Standard Deviation: %.4f\n', stats_filtered.std);
fprintf('  RMS: %.4f\n', stats_filtered.rms);
fprintf('  Noise Reduction: %.2f dB\n', ...
    20*log10(stats_original.std / stats_filtered.std));

%% Feature extraction
fprintf('\nExtracting signal features...\n');

% Zero crossing rate
zero_crossings = sum(diff(sign(signal_complex)) ~= 0) / length(signal_complex);

% Spectral centroid
spectral_centroid = sum(freq .* mag_complex) / sum(mag_complex);

% Spectral bandwidth
spectral_bandwidth = sqrt(sum(((freq - spectral_centroid).^2) .* mag_complex) / sum(mag_complex));

% Peak detection
[peaks, peak_locations] = findpeaks(signal_complex, 'MinPeakHeight', 0.5, 'MinPeakDistance', 50);

fprintf('Feature Extraction Results:\n');
fprintf('  Zero Crossing Rate: %.4f\n', zero_crossings);
fprintf('  Spectral Centroid: %.2f Hz\n', spectral_centroid);
fprintf('  Spectral Bandwidth: %.2f Hz\n', spectral_bandwidth);
fprintf('  Number of Peaks: %d\n', length(peaks));

%% Save results
fprintf('\nSaving results...\n');

% Create results structure
results = struct();
results.time = t;
results.signals = struct('clean', signal_clean, 'noisy', signal_noisy, ...
                        'complex', signal_complex, 'filtered', signal_lowpass);
results.frequency = freq;
results.spectra = struct('clean', mag_clean, 'complex', mag_complex);
results.filters = struct('lowpass', [b_low; a_low], 'bandpass', [b_band; a_band]);
results.statistics = struct('original', stats_original, 'filtered', stats_filtered);
results.features = struct('zero_crossings', zero_crossings, ...
                         'spectral_centroid', spectral_centroid, ...
                         'spectral_bandwidth', spectral_bandwidth);

% Save to .mat file
save('signal_analysis_results.mat', 'results');

% Export key data to CSV for external analysis
data_export = [t', signal_clean', signal_noisy', signal_complex', signal_lowpass'];
writematrix(data_export, 'signal_data.csv');

% Save figure
saveas(gcf, 'signal_analysis_plots.png');
saveas(gcf, 'signal_analysis_plots.fig');

fprintf('Analysis complete!\n');
fprintf('Files saved:\n');
fprintf('  - signal_analysis_results.mat\n');
fprintf('  - signal_data.csv\n');
fprintf('  - signal_analysis_plots.png\n');
fprintf('  - signal_analysis_plots.fig\n');

%% Function definitions (would typically be in separate files)
function filtered_signal = apply_moving_average(signal, window_size)
    % Apply moving average filter
    kernel = ones(1, window_size) / window_size;
    filtered_signal = conv(signal, kernel, 'same');
end

function snr_db = calculate_snr(signal, noise)
    % Calculate Signal-to-Noise Ratio in dB
    signal_power = mean(signal.^2);
    noise_power = mean(noise.^2);
    snr_db = 10 * log10(signal_power / noise_power);
end